strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSConsole:
  785    '''
  786    AWSConsole is currently unstable, and its API may change, or it may be removed,
  787    without a major version bump.
  788    '''
  789    __slots__ = [
  790        'bind_interface',
  791        'egress_filter',
  792        'enable_env_variables',
  793        'healthy',
  794        'id',
  795        'name',
  796        'port_override',
  797        'region',
  798        'remote_identity_group_id',
  799        'remote_identity_healthcheck_username',
  800        'role_arn',
  801        'role_external_id',
  802        'secret_store_id',
  803        'session_expiry',
  804        'subdomain',
  805        'tags',
  806    ]
  807
  808    def __init__(
  809        self,
  810        bind_interface=None,
  811        egress_filter=None,
  812        enable_env_variables=None,
  813        healthy=None,
  814        id=None,
  815        name=None,
  816        port_override=None,
  817        region=None,
  818        remote_identity_group_id=None,
  819        remote_identity_healthcheck_username=None,
  820        role_arn=None,
  821        role_external_id=None,
  822        secret_store_id=None,
  823        session_expiry=None,
  824        subdomain=None,
  825        tags=None,
  826    ):
  827        self.bind_interface = bind_interface if bind_interface is not None else ''
  828        '''
  829         Bind interface
  830        '''
  831        self.egress_filter = egress_filter if egress_filter is not None else ''
  832        '''
  833         A filter applied to the routing logic to pin datasource to nodes.
  834        '''
  835        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
  836        self.healthy = healthy if healthy is not None else False
  837        '''
  838         True if the datasource is reachable and the credentials are valid.
  839        '''
  840        self.id = id if id is not None else ''
  841        '''
  842         Unique identifier of the Resource.
  843        '''
  844        self.name = name if name is not None else ''
  845        '''
  846         Unique human-readable name of the Resource.
  847        '''
  848        self.port_override = port_override if port_override is not None else 0
  849        self.region = region if region is not None else ''
  850        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  851        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  852        self.role_arn = role_arn if role_arn is not None else ''
  853        self.role_external_id = role_external_id if role_external_id is not None else ''
  854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  855        '''
  856         ID of the secret store containing credentials for this resource, if any.
  857        '''
  858        self.session_expiry = session_expiry if session_expiry is not None else 0
  859        self.subdomain = subdomain if subdomain is not None else ''
  860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  861        '''
  862         Tags is a map of key, value pairs.
  863        '''
  864
  865    def __repr__(self):
  866        return '<sdm.AWSConsole ' + \
  867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  869            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
  870            'healthy: ' + repr(self.healthy) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'name: ' + repr(self.name) + ' ' +\
  873            'port_override: ' + repr(self.port_override) + ' ' +\
  874            'region: ' + repr(self.region) + ' ' +\
  875            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  876            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  877            'role_arn: ' + repr(self.role_arn) + ' ' +\
  878            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  880            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
  881            'subdomain: ' + repr(self.subdomain) + ' ' +\
  882            'tags: ' + repr(self.tags) + ' ' +\
  883            '>'
  884
  885    def to_dict(self):
  886        return {
  887            'bind_interface': self.bind_interface,
  888            'egress_filter': self.egress_filter,
  889            'enable_env_variables': self.enable_env_variables,
  890            'healthy': self.healthy,
  891            'id': self.id,
  892            'name': self.name,
  893            'port_override': self.port_override,
  894            'region': self.region,
  895            'remote_identity_group_id': self.remote_identity_group_id,
  896            'remote_identity_healthcheck_username':
  897            self.remote_identity_healthcheck_username,
  898            'role_arn': self.role_arn,
  899            'role_external_id': self.role_external_id,
  900            'secret_store_id': self.secret_store_id,
  901            'session_expiry': self.session_expiry,
  902            'subdomain': self.subdomain,
  903            'tags': self.tags,
  904        }
  905
  906    @classmethod
  907    def from_dict(cls, d):
  908        return cls(
  909            bind_interface=d.get('bind_interface'),
  910            egress_filter=d.get('egress_filter'),
  911            enable_env_variables=d.get('enable_env_variables'),
  912            healthy=d.get('healthy'),
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            port_override=d.get('port_override'),
  916            region=d.get('region'),
  917            remote_identity_group_id=d.get('remote_identity_group_id'),
  918            remote_identity_healthcheck_username=d.get(
  919                'remote_identity_healthcheck_username'),
  920            role_arn=d.get('role_arn'),
  921            role_external_id=d.get('role_external_id'),
  922            secret_store_id=d.get('secret_store_id'),
  923            session_expiry=d.get('session_expiry'),
  924            subdomain=d.get('subdomain'),
  925            tags=d.get('tags'),
  926        )
  927
  928
  929class AWSConsoleStaticKeyPair:
  930    '''
  931    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
  932    without a major version bump.
  933    '''
  934    __slots__ = [
  935        'access_key',
  936        'bind_interface',
  937        'egress_filter',
  938        'healthy',
  939        'id',
  940        'name',
  941        'port_override',
  942        'region',
  943        'remote_identity_group_id',
  944        'remote_identity_healthcheck_username',
  945        'role_arn',
  946        'role_external_id',
  947        'secret_access_key',
  948        'secret_store_id',
  949        'session_expiry',
  950        'subdomain',
  951        'tags',
  952    ]
  953
  954    def __init__(
  955        self,
  956        access_key=None,
  957        bind_interface=None,
  958        egress_filter=None,
  959        healthy=None,
  960        id=None,
  961        name=None,
  962        port_override=None,
  963        region=None,
  964        remote_identity_group_id=None,
  965        remote_identity_healthcheck_username=None,
  966        role_arn=None,
  967        role_external_id=None,
  968        secret_access_key=None,
  969        secret_store_id=None,
  970        session_expiry=None,
  971        subdomain=None,
  972        tags=None,
  973    ):
  974        self.access_key = access_key if access_key is not None else ''
  975        self.bind_interface = bind_interface if bind_interface is not None else ''
  976        '''
  977         Bind interface
  978        '''
  979        self.egress_filter = egress_filter if egress_filter is not None else ''
  980        '''
  981         A filter applied to the routing logic to pin datasource to nodes.
  982        '''
  983        self.healthy = healthy if healthy is not None else False
  984        '''
  985         True if the datasource is reachable and the credentials are valid.
  986        '''
  987        self.id = id if id is not None else ''
  988        '''
  989         Unique identifier of the Resource.
  990        '''
  991        self.name = name if name is not None else ''
  992        '''
  993         Unique human-readable name of the Resource.
  994        '''
  995        self.port_override = port_override if port_override is not None else 0
  996        self.region = region if region is not None else ''
  997        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  998        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  999        self.role_arn = role_arn if role_arn is not None else ''
 1000        self.role_external_id = role_external_id if role_external_id is not None else ''
 1001        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1003        '''
 1004         ID of the secret store containing credentials for this resource, if any.
 1005        '''
 1006        self.session_expiry = session_expiry if session_expiry is not None else 0
 1007        self.subdomain = subdomain if subdomain is not None else ''
 1008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1009        '''
 1010         Tags is a map of key, value pairs.
 1011        '''
 1012
 1013    def __repr__(self):
 1014        return '<sdm.AWSConsoleStaticKeyPair ' + \
 1015            'access_key: ' + repr(self.access_key) + ' ' +\
 1016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1018            'healthy: ' + repr(self.healthy) + ' ' +\
 1019            'id: ' + repr(self.id) + ' ' +\
 1020            'name: ' + repr(self.name) + ' ' +\
 1021            'port_override: ' + repr(self.port_override) + ' ' +\
 1022            'region: ' + repr(self.region) + ' ' +\
 1023            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1024            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1025            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1026            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1027            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1029            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
 1030            'subdomain: ' + repr(self.subdomain) + ' ' +\
 1031            'tags: ' + repr(self.tags) + ' ' +\
 1032            '>'
 1033
 1034    def to_dict(self):
 1035        return {
 1036            'access_key': self.access_key,
 1037            'bind_interface': self.bind_interface,
 1038            'egress_filter': self.egress_filter,
 1039            'healthy': self.healthy,
 1040            'id': self.id,
 1041            'name': self.name,
 1042            'port_override': self.port_override,
 1043            'region': self.region,
 1044            'remote_identity_group_id': self.remote_identity_group_id,
 1045            'remote_identity_healthcheck_username':
 1046            self.remote_identity_healthcheck_username,
 1047            'role_arn': self.role_arn,
 1048            'role_external_id': self.role_external_id,
 1049            'secret_access_key': self.secret_access_key,
 1050            'secret_store_id': self.secret_store_id,
 1051            'session_expiry': self.session_expiry,
 1052            'subdomain': self.subdomain,
 1053            'tags': self.tags,
 1054        }
 1055
 1056    @classmethod
 1057    def from_dict(cls, d):
 1058        return cls(
 1059            access_key=d.get('access_key'),
 1060            bind_interface=d.get('bind_interface'),
 1061            egress_filter=d.get('egress_filter'),
 1062            healthy=d.get('healthy'),
 1063            id=d.get('id'),
 1064            name=d.get('name'),
 1065            port_override=d.get('port_override'),
 1066            region=d.get('region'),
 1067            remote_identity_group_id=d.get('remote_identity_group_id'),
 1068            remote_identity_healthcheck_username=d.get(
 1069                'remote_identity_healthcheck_username'),
 1070            role_arn=d.get('role_arn'),
 1071            role_external_id=d.get('role_external_id'),
 1072            secret_access_key=d.get('secret_access_key'),
 1073            secret_store_id=d.get('secret_store_id'),
 1074            session_expiry=d.get('session_expiry'),
 1075            subdomain=d.get('subdomain'),
 1076            tags=d.get('tags'),
 1077        )
 1078
 1079
 1080class AWSStore:
 1081    __slots__ = [
 1082        'id',
 1083        'name',
 1084        'region',
 1085        'tags',
 1086    ]
 1087
 1088    def __init__(
 1089        self,
 1090        id=None,
 1091        name=None,
 1092        region=None,
 1093        tags=None,
 1094    ):
 1095        self.id = id if id is not None else ''
 1096        '''
 1097         Unique identifier of the SecretStore.
 1098        '''
 1099        self.name = name if name is not None else ''
 1100        '''
 1101         Unique human-readable name of the SecretStore.
 1102        '''
 1103        self.region = region if region is not None else ''
 1104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1105        '''
 1106         Tags is a map of key, value pairs.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AWSStore ' + \
 1111            'id: ' + repr(self.id) + ' ' +\
 1112            'name: ' + repr(self.name) + ' ' +\
 1113            'region: ' + repr(self.region) + ' ' +\
 1114            'tags: ' + repr(self.tags) + ' ' +\
 1115            '>'
 1116
 1117    def to_dict(self):
 1118        return {
 1119            'id': self.id,
 1120            'name': self.name,
 1121            'region': self.region,
 1122            'tags': self.tags,
 1123        }
 1124
 1125    @classmethod
 1126    def from_dict(cls, d):
 1127        return cls(
 1128            id=d.get('id'),
 1129            name=d.get('name'),
 1130            region=d.get('region'),
 1131            tags=d.get('tags'),
 1132        )
 1133
 1134
 1135class AccountAttachment:
 1136    '''
 1137         AccountAttachments assign an account to a role.
 1138    '''
 1139    __slots__ = [
 1140        'account_id',
 1141        'id',
 1142        'role_id',
 1143    ]
 1144
 1145    def __init__(
 1146        self,
 1147        account_id=None,
 1148        id=None,
 1149        role_id=None,
 1150    ):
 1151        self.account_id = account_id if account_id is not None else ''
 1152        '''
 1153         The id of the account of this AccountAttachment.
 1154        '''
 1155        self.id = id if id is not None else ''
 1156        '''
 1157         Unique identifier of the AccountAttachment.
 1158        '''
 1159        self.role_id = role_id if role_id is not None else ''
 1160        '''
 1161         The id of the attached role of this AccountAttachment.
 1162        '''
 1163
 1164    def __repr__(self):
 1165        return '<sdm.AccountAttachment ' + \
 1166            'account_id: ' + repr(self.account_id) + ' ' +\
 1167            'id: ' + repr(self.id) + ' ' +\
 1168            'role_id: ' + repr(self.role_id) + ' ' +\
 1169            '>'
 1170
 1171    def to_dict(self):
 1172        return {
 1173            'account_id': self.account_id,
 1174            'id': self.id,
 1175            'role_id': self.role_id,
 1176        }
 1177
 1178    @classmethod
 1179    def from_dict(cls, d):
 1180        return cls(
 1181            account_id=d.get('account_id'),
 1182            id=d.get('id'),
 1183            role_id=d.get('role_id'),
 1184        )
 1185
 1186
 1187class AccountAttachmentCreateResponse:
 1188    '''
 1189         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1190    '''
 1191    __slots__ = [
 1192        'account_attachment',
 1193        'meta',
 1194        'rate_limit',
 1195    ]
 1196
 1197    def __init__(
 1198        self,
 1199        account_attachment=None,
 1200        meta=None,
 1201        rate_limit=None,
 1202    ):
 1203        self.account_attachment = account_attachment if account_attachment is not None else None
 1204        '''
 1205         The created AccountAttachment.
 1206        '''
 1207        self.meta = meta if meta is not None else None
 1208        '''
 1209         Reserved for future use.
 1210        '''
 1211        self.rate_limit = rate_limit if rate_limit is not None else None
 1212        '''
 1213         Rate limit information.
 1214        '''
 1215
 1216    def __repr__(self):
 1217        return '<sdm.AccountAttachmentCreateResponse ' + \
 1218            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1219            'meta: ' + repr(self.meta) + ' ' +\
 1220            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1221            '>'
 1222
 1223    def to_dict(self):
 1224        return {
 1225            'account_attachment': self.account_attachment,
 1226            'meta': self.meta,
 1227            'rate_limit': self.rate_limit,
 1228        }
 1229
 1230    @classmethod
 1231    def from_dict(cls, d):
 1232        return cls(
 1233            account_attachment=d.get('account_attachment'),
 1234            meta=d.get('meta'),
 1235            rate_limit=d.get('rate_limit'),
 1236        )
 1237
 1238
 1239class AccountAttachmentDeleteResponse:
 1240    '''
 1241         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1242    '''
 1243    __slots__ = [
 1244        'meta',
 1245        'rate_limit',
 1246    ]
 1247
 1248    def __init__(
 1249        self,
 1250        meta=None,
 1251        rate_limit=None,
 1252    ):
 1253        self.meta = meta if meta is not None else None
 1254        '''
 1255         Reserved for future use.
 1256        '''
 1257        self.rate_limit = rate_limit if rate_limit is not None else None
 1258        '''
 1259         Rate limit information.
 1260        '''
 1261
 1262    def __repr__(self):
 1263        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1264            'meta: ' + repr(self.meta) + ' ' +\
 1265            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1266            '>'
 1267
 1268    def to_dict(self):
 1269        return {
 1270            'meta': self.meta,
 1271            'rate_limit': self.rate_limit,
 1272        }
 1273
 1274    @classmethod
 1275    def from_dict(cls, d):
 1276        return cls(
 1277            meta=d.get('meta'),
 1278            rate_limit=d.get('rate_limit'),
 1279        )
 1280
 1281
 1282class AccountAttachmentGetResponse:
 1283    '''
 1284         AccountAttachmentGetResponse returns a requested AccountAttachment.
 1285    '''
 1286    __slots__ = [
 1287        'account_attachment',
 1288        'meta',
 1289        'rate_limit',
 1290    ]
 1291
 1292    def __init__(
 1293        self,
 1294        account_attachment=None,
 1295        meta=None,
 1296        rate_limit=None,
 1297    ):
 1298        self.account_attachment = account_attachment if account_attachment is not None else None
 1299        '''
 1300         The requested AccountAttachment.
 1301        '''
 1302        self.meta = meta if meta is not None else None
 1303        '''
 1304         Reserved for future use.
 1305        '''
 1306        self.rate_limit = rate_limit if rate_limit is not None else None
 1307        '''
 1308         Rate limit information.
 1309        '''
 1310
 1311    def __repr__(self):
 1312        return '<sdm.AccountAttachmentGetResponse ' + \
 1313            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1314            'meta: ' + repr(self.meta) + ' ' +\
 1315            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1316            '>'
 1317
 1318    def to_dict(self):
 1319        return {
 1320            'account_attachment': self.account_attachment,
 1321            'meta': self.meta,
 1322            'rate_limit': self.rate_limit,
 1323        }
 1324
 1325    @classmethod
 1326    def from_dict(cls, d):
 1327        return cls(
 1328            account_attachment=d.get('account_attachment'),
 1329            meta=d.get('meta'),
 1330            rate_limit=d.get('rate_limit'),
 1331        )
 1332
 1333
 1334class AccountCreateResponse:
 1335    '''
 1336         AccountCreateResponse reports how the Accounts were created in the system.
 1337    '''
 1338    __slots__ = [
 1339        'account',
 1340        'meta',
 1341        'rate_limit',
 1342        'token',
 1343    ]
 1344
 1345    def __init__(
 1346        self,
 1347        account=None,
 1348        meta=None,
 1349        rate_limit=None,
 1350        token=None,
 1351    ):
 1352        self.account = account if account is not None else None
 1353        '''
 1354         The created Account.
 1355        '''
 1356        self.meta = meta if meta is not None else None
 1357        '''
 1358         Reserved for future use.
 1359        '''
 1360        self.rate_limit = rate_limit if rate_limit is not None else None
 1361        '''
 1362         Rate limit information.
 1363        '''
 1364        self.token = token if token is not None else ''
 1365        '''
 1366         The auth token generated for the Account. The Account will use this token to
 1367         authenticate with the strongDM API.
 1368        '''
 1369
 1370    def __repr__(self):
 1371        return '<sdm.AccountCreateResponse ' + \
 1372            'account: ' + repr(self.account) + ' ' +\
 1373            'meta: ' + repr(self.meta) + ' ' +\
 1374            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1375            'token: ' + repr(self.token) + ' ' +\
 1376            '>'
 1377
 1378    def to_dict(self):
 1379        return {
 1380            'account': self.account,
 1381            'meta': self.meta,
 1382            'rate_limit': self.rate_limit,
 1383            'token': self.token,
 1384        }
 1385
 1386    @classmethod
 1387    def from_dict(cls, d):
 1388        return cls(
 1389            account=d.get('account'),
 1390            meta=d.get('meta'),
 1391            rate_limit=d.get('rate_limit'),
 1392            token=d.get('token'),
 1393        )
 1394
 1395
 1396class AccountDeleteResponse:
 1397    '''
 1398         AccountDeleteResponse returns information about a Account that was deleted.
 1399    '''
 1400    __slots__ = [
 1401        'meta',
 1402        'rate_limit',
 1403    ]
 1404
 1405    def __init__(
 1406        self,
 1407        meta=None,
 1408        rate_limit=None,
 1409    ):
 1410        self.meta = meta if meta is not None else None
 1411        '''
 1412         Reserved for future use.
 1413        '''
 1414        self.rate_limit = rate_limit if rate_limit is not None else None
 1415        '''
 1416         Rate limit information.
 1417        '''
 1418
 1419    def __repr__(self):
 1420        return '<sdm.AccountDeleteResponse ' + \
 1421            'meta: ' + repr(self.meta) + ' ' +\
 1422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1423            '>'
 1424
 1425    def to_dict(self):
 1426        return {
 1427            'meta': self.meta,
 1428            'rate_limit': self.rate_limit,
 1429        }
 1430
 1431    @classmethod
 1432    def from_dict(cls, d):
 1433        return cls(
 1434            meta=d.get('meta'),
 1435            rate_limit=d.get('rate_limit'),
 1436        )
 1437
 1438
 1439class AccountGetResponse:
 1440    '''
 1441         AccountGetResponse returns a requested Account.
 1442    '''
 1443    __slots__ = [
 1444        'account',
 1445        'meta',
 1446        'rate_limit',
 1447    ]
 1448
 1449    def __init__(
 1450        self,
 1451        account=None,
 1452        meta=None,
 1453        rate_limit=None,
 1454    ):
 1455        self.account = account if account is not None else None
 1456        '''
 1457         The requested Account.
 1458        '''
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGetResponse ' + \
 1470            'account: ' + repr(self.account) + ' ' +\
 1471            'meta: ' + repr(self.meta) + ' ' +\
 1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1473            '>'
 1474
 1475    def to_dict(self):
 1476        return {
 1477            'account': self.account,
 1478            'meta': self.meta,
 1479            'rate_limit': self.rate_limit,
 1480        }
 1481
 1482    @classmethod
 1483    def from_dict(cls, d):
 1484        return cls(
 1485            account=d.get('account'),
 1486            meta=d.get('meta'),
 1487            rate_limit=d.get('rate_limit'),
 1488        )
 1489
 1490
 1491class AccountGrant:
 1492    '''
 1493         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1494    '''
 1495    __slots__ = [
 1496        'account_id',
 1497        'id',
 1498        'resource_id',
 1499        'start_from',
 1500        'valid_until',
 1501    ]
 1502
 1503    def __init__(
 1504        self,
 1505        account_id=None,
 1506        id=None,
 1507        resource_id=None,
 1508        start_from=None,
 1509        valid_until=None,
 1510    ):
 1511        self.account_id = account_id if account_id is not None else ''
 1512        '''
 1513         The account ID of this AccountGrant.
 1514        '''
 1515        self.id = id if id is not None else ''
 1516        '''
 1517         Unique identifier of the AccountGrant.
 1518        '''
 1519        self.resource_id = resource_id if resource_id is not None else ''
 1520        '''
 1521         The resource ID of this AccountGrant.
 1522        '''
 1523        self.start_from = start_from if start_from is not None else None
 1524        '''
 1525         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1526        '''
 1527        self.valid_until = valid_until if valid_until is not None else None
 1528        '''
 1529         The timestamp when the resource grant will expire.
 1530        '''
 1531
 1532    def __repr__(self):
 1533        return '<sdm.AccountGrant ' + \
 1534            'account_id: ' + repr(self.account_id) + ' ' +\
 1535            'id: ' + repr(self.id) + ' ' +\
 1536            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1537            'start_from: ' + repr(self.start_from) + ' ' +\
 1538            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1539            '>'
 1540
 1541    def to_dict(self):
 1542        return {
 1543            'account_id': self.account_id,
 1544            'id': self.id,
 1545            'resource_id': self.resource_id,
 1546            'start_from': self.start_from,
 1547            'valid_until': self.valid_until,
 1548        }
 1549
 1550    @classmethod
 1551    def from_dict(cls, d):
 1552        return cls(
 1553            account_id=d.get('account_id'),
 1554            id=d.get('id'),
 1555            resource_id=d.get('resource_id'),
 1556            start_from=d.get('start_from'),
 1557            valid_until=d.get('valid_until'),
 1558        )
 1559
 1560
 1561class AccountGrantCreateResponse:
 1562    '''
 1563         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1564    '''
 1565    __slots__ = [
 1566        'account_grant',
 1567        'meta',
 1568        'rate_limit',
 1569    ]
 1570
 1571    def __init__(
 1572        self,
 1573        account_grant=None,
 1574        meta=None,
 1575        rate_limit=None,
 1576    ):
 1577        self.account_grant = account_grant if account_grant is not None else None
 1578        '''
 1579         The created AccountGrant.
 1580        '''
 1581        self.meta = meta if meta is not None else None
 1582        '''
 1583         Reserved for future use.
 1584        '''
 1585        self.rate_limit = rate_limit if rate_limit is not None else None
 1586        '''
 1587         Rate limit information.
 1588        '''
 1589
 1590    def __repr__(self):
 1591        return '<sdm.AccountGrantCreateResponse ' + \
 1592            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1593            'meta: ' + repr(self.meta) + ' ' +\
 1594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1595            '>'
 1596
 1597    def to_dict(self):
 1598        return {
 1599            'account_grant': self.account_grant,
 1600            'meta': self.meta,
 1601            'rate_limit': self.rate_limit,
 1602        }
 1603
 1604    @classmethod
 1605    def from_dict(cls, d):
 1606        return cls(
 1607            account_grant=d.get('account_grant'),
 1608            meta=d.get('meta'),
 1609            rate_limit=d.get('rate_limit'),
 1610        )
 1611
 1612
 1613class AccountGrantDeleteResponse:
 1614    '''
 1615         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1616    '''
 1617    __slots__ = [
 1618        'meta',
 1619        'rate_limit',
 1620    ]
 1621
 1622    def __init__(
 1623        self,
 1624        meta=None,
 1625        rate_limit=None,
 1626    ):
 1627        self.meta = meta if meta is not None else None
 1628        '''
 1629         Reserved for future use.
 1630        '''
 1631        self.rate_limit = rate_limit if rate_limit is not None else None
 1632        '''
 1633         Rate limit information.
 1634        '''
 1635
 1636    def __repr__(self):
 1637        return '<sdm.AccountGrantDeleteResponse ' + \
 1638            'meta: ' + repr(self.meta) + ' ' +\
 1639            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1640            '>'
 1641
 1642    def to_dict(self):
 1643        return {
 1644            'meta': self.meta,
 1645            'rate_limit': self.rate_limit,
 1646        }
 1647
 1648    @classmethod
 1649    def from_dict(cls, d):
 1650        return cls(
 1651            meta=d.get('meta'),
 1652            rate_limit=d.get('rate_limit'),
 1653        )
 1654
 1655
 1656class AccountGrantGetResponse:
 1657    '''
 1658         AccountGrantGetResponse returns a requested AccountGrant.
 1659    '''
 1660    __slots__ = [
 1661        'account_grant',
 1662        'meta',
 1663        'rate_limit',
 1664    ]
 1665
 1666    def __init__(
 1667        self,
 1668        account_grant=None,
 1669        meta=None,
 1670        rate_limit=None,
 1671    ):
 1672        self.account_grant = account_grant if account_grant is not None else None
 1673        '''
 1674         The requested AccountGrant.
 1675        '''
 1676        self.meta = meta if meta is not None else None
 1677        '''
 1678         Reserved for future use.
 1679        '''
 1680        self.rate_limit = rate_limit if rate_limit is not None else None
 1681        '''
 1682         Rate limit information.
 1683        '''
 1684
 1685    def __repr__(self):
 1686        return '<sdm.AccountGrantGetResponse ' + \
 1687            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1688            'meta: ' + repr(self.meta) + ' ' +\
 1689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1690            '>'
 1691
 1692    def to_dict(self):
 1693        return {
 1694            'account_grant': self.account_grant,
 1695            'meta': self.meta,
 1696            'rate_limit': self.rate_limit,
 1697        }
 1698
 1699    @classmethod
 1700    def from_dict(cls, d):
 1701        return cls(
 1702            account_grant=d.get('account_grant'),
 1703            meta=d.get('meta'),
 1704            rate_limit=d.get('rate_limit'),
 1705        )
 1706
 1707
 1708class AccountUpdateResponse:
 1709    '''
 1710         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1711     a AccountUpdateRequest.
 1712    '''
 1713    __slots__ = [
 1714        'account',
 1715        'meta',
 1716        'rate_limit',
 1717    ]
 1718
 1719    def __init__(
 1720        self,
 1721        account=None,
 1722        meta=None,
 1723        rate_limit=None,
 1724    ):
 1725        self.account = account if account is not None else None
 1726        '''
 1727         The updated Account.
 1728        '''
 1729        self.meta = meta if meta is not None else None
 1730        '''
 1731         Reserved for future use.
 1732        '''
 1733        self.rate_limit = rate_limit if rate_limit is not None else None
 1734        '''
 1735         Rate limit information.
 1736        '''
 1737
 1738    def __repr__(self):
 1739        return '<sdm.AccountUpdateResponse ' + \
 1740            'account: ' + repr(self.account) + ' ' +\
 1741            'meta: ' + repr(self.meta) + ' ' +\
 1742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1743            '>'
 1744
 1745    def to_dict(self):
 1746        return {
 1747            'account': self.account,
 1748            'meta': self.meta,
 1749            'rate_limit': self.rate_limit,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            account=d.get('account'),
 1756            meta=d.get('meta'),
 1757            rate_limit=d.get('rate_limit'),
 1758        )
 1759
 1760
 1761class AmazonEKS:
 1762    __slots__ = [
 1763        'access_key',
 1764        'bind_interface',
 1765        'certificate_authority',
 1766        'cluster_name',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthcheck_namespace',
 1770        'healthy',
 1771        'id',
 1772        'name',
 1773        'region',
 1774        'remote_identity_group_id',
 1775        'remote_identity_healthcheck_username',
 1776        'role_arn',
 1777        'role_external_id',
 1778        'secret_access_key',
 1779        'secret_store_id',
 1780        'tags',
 1781    ]
 1782
 1783    def __init__(
 1784        self,
 1785        access_key=None,
 1786        bind_interface=None,
 1787        certificate_authority=None,
 1788        cluster_name=None,
 1789        egress_filter=None,
 1790        endpoint=None,
 1791        healthcheck_namespace=None,
 1792        healthy=None,
 1793        id=None,
 1794        name=None,
 1795        region=None,
 1796        remote_identity_group_id=None,
 1797        remote_identity_healthcheck_username=None,
 1798        role_arn=None,
 1799        role_external_id=None,
 1800        secret_access_key=None,
 1801        secret_store_id=None,
 1802        tags=None,
 1803    ):
 1804        self.access_key = access_key if access_key is not None else ''
 1805        self.bind_interface = bind_interface if bind_interface is not None else ''
 1806        '''
 1807         Bind interface
 1808        '''
 1809        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1810        self.cluster_name = cluster_name if cluster_name is not None else ''
 1811        self.egress_filter = egress_filter if egress_filter is not None else ''
 1812        '''
 1813         A filter applied to the routing logic to pin datasource to nodes.
 1814        '''
 1815        self.endpoint = endpoint if endpoint is not None else ''
 1816        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1817        '''
 1818         The path used to check the health of your connection.  Defaults to `default`.
 1819        '''
 1820        self.healthy = healthy if healthy is not None else False
 1821        '''
 1822         True if the datasource is reachable and the credentials are valid.
 1823        '''
 1824        self.id = id if id is not None else ''
 1825        '''
 1826         Unique identifier of the Resource.
 1827        '''
 1828        self.name = name if name is not None else ''
 1829        '''
 1830         Unique human-readable name of the Resource.
 1831        '''
 1832        self.region = region if region is not None else ''
 1833        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1834        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1835        self.role_arn = role_arn if role_arn is not None else ''
 1836        self.role_external_id = role_external_id if role_external_id is not None else ''
 1837        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1839        '''
 1840         ID of the secret store containing credentials for this resource, if any.
 1841        '''
 1842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1843        '''
 1844         Tags is a map of key, value pairs.
 1845        '''
 1846
 1847    def __repr__(self):
 1848        return '<sdm.AmazonEKS ' + \
 1849            'access_key: ' + repr(self.access_key) + ' ' +\
 1850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1851            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1852            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1854            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1855            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1856            'healthy: ' + repr(self.healthy) + ' ' +\
 1857            'id: ' + repr(self.id) + ' ' +\
 1858            'name: ' + repr(self.name) + ' ' +\
 1859            'region: ' + repr(self.region) + ' ' +\
 1860            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1861            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1862            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1863            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1864            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1866            'tags: ' + repr(self.tags) + ' ' +\
 1867            '>'
 1868
 1869    def to_dict(self):
 1870        return {
 1871            'access_key': self.access_key,
 1872            'bind_interface': self.bind_interface,
 1873            'certificate_authority': self.certificate_authority,
 1874            'cluster_name': self.cluster_name,
 1875            'egress_filter': self.egress_filter,
 1876            'endpoint': self.endpoint,
 1877            'healthcheck_namespace': self.healthcheck_namespace,
 1878            'healthy': self.healthy,
 1879            'id': self.id,
 1880            'name': self.name,
 1881            'region': self.region,
 1882            'remote_identity_group_id': self.remote_identity_group_id,
 1883            'remote_identity_healthcheck_username':
 1884            self.remote_identity_healthcheck_username,
 1885            'role_arn': self.role_arn,
 1886            'role_external_id': self.role_external_id,
 1887            'secret_access_key': self.secret_access_key,
 1888            'secret_store_id': self.secret_store_id,
 1889            'tags': self.tags,
 1890        }
 1891
 1892    @classmethod
 1893    def from_dict(cls, d):
 1894        return cls(
 1895            access_key=d.get('access_key'),
 1896            bind_interface=d.get('bind_interface'),
 1897            certificate_authority=d.get('certificate_authority'),
 1898            cluster_name=d.get('cluster_name'),
 1899            egress_filter=d.get('egress_filter'),
 1900            endpoint=d.get('endpoint'),
 1901            healthcheck_namespace=d.get('healthcheck_namespace'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            region=d.get('region'),
 1906            remote_identity_group_id=d.get('remote_identity_group_id'),
 1907            remote_identity_healthcheck_username=d.get(
 1908                'remote_identity_healthcheck_username'),
 1909            role_arn=d.get('role_arn'),
 1910            role_external_id=d.get('role_external_id'),
 1911            secret_access_key=d.get('secret_access_key'),
 1912            secret_store_id=d.get('secret_store_id'),
 1913            tags=d.get('tags'),
 1914        )
 1915
 1916
 1917class AmazonEKSUserImpersonation:
 1918    __slots__ = [
 1919        'access_key',
 1920        'bind_interface',
 1921        'certificate_authority',
 1922        'cluster_name',
 1923        'egress_filter',
 1924        'endpoint',
 1925        'healthcheck_namespace',
 1926        'healthy',
 1927        'id',
 1928        'name',
 1929        'region',
 1930        'role_arn',
 1931        'role_external_id',
 1932        'secret_access_key',
 1933        'secret_store_id',
 1934        'tags',
 1935    ]
 1936
 1937    def __init__(
 1938        self,
 1939        access_key=None,
 1940        bind_interface=None,
 1941        certificate_authority=None,
 1942        cluster_name=None,
 1943        egress_filter=None,
 1944        endpoint=None,
 1945        healthcheck_namespace=None,
 1946        healthy=None,
 1947        id=None,
 1948        name=None,
 1949        region=None,
 1950        role_arn=None,
 1951        role_external_id=None,
 1952        secret_access_key=None,
 1953        secret_store_id=None,
 1954        tags=None,
 1955    ):
 1956        self.access_key = access_key if access_key is not None else ''
 1957        self.bind_interface = bind_interface if bind_interface is not None else ''
 1958        '''
 1959         Bind interface
 1960        '''
 1961        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1962        self.cluster_name = cluster_name if cluster_name is not None else ''
 1963        self.egress_filter = egress_filter if egress_filter is not None else ''
 1964        '''
 1965         A filter applied to the routing logic to pin datasource to nodes.
 1966        '''
 1967        self.endpoint = endpoint if endpoint is not None else ''
 1968        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1969        '''
 1970         The path used to check the health of your connection.  Defaults to `default`.
 1971        '''
 1972        self.healthy = healthy if healthy is not None else False
 1973        '''
 1974         True if the datasource is reachable and the credentials are valid.
 1975        '''
 1976        self.id = id if id is not None else ''
 1977        '''
 1978         Unique identifier of the Resource.
 1979        '''
 1980        self.name = name if name is not None else ''
 1981        '''
 1982         Unique human-readable name of the Resource.
 1983        '''
 1984        self.region = region if region is not None else ''
 1985        self.role_arn = role_arn if role_arn is not None else ''
 1986        self.role_external_id = role_external_id if role_external_id is not None else ''
 1987        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1988        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1989        '''
 1990         ID of the secret store containing credentials for this resource, if any.
 1991        '''
 1992        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1993        '''
 1994         Tags is a map of key, value pairs.
 1995        '''
 1996
 1997    def __repr__(self):
 1998        return '<sdm.AmazonEKSUserImpersonation ' + \
 1999            'access_key: ' + repr(self.access_key) + ' ' +\
 2000            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2001            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2002            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2003            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2004            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2005            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2006            'healthy: ' + repr(self.healthy) + ' ' +\
 2007            'id: ' + repr(self.id) + ' ' +\
 2008            'name: ' + repr(self.name) + ' ' +\
 2009            'region: ' + repr(self.region) + ' ' +\
 2010            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2011            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2012            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2013            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2014            'tags: ' + repr(self.tags) + ' ' +\
 2015            '>'
 2016
 2017    def to_dict(self):
 2018        return {
 2019            'access_key': self.access_key,
 2020            'bind_interface': self.bind_interface,
 2021            'certificate_authority': self.certificate_authority,
 2022            'cluster_name': self.cluster_name,
 2023            'egress_filter': self.egress_filter,
 2024            'endpoint': self.endpoint,
 2025            'healthcheck_namespace': self.healthcheck_namespace,
 2026            'healthy': self.healthy,
 2027            'id': self.id,
 2028            'name': self.name,
 2029            'region': self.region,
 2030            'role_arn': self.role_arn,
 2031            'role_external_id': self.role_external_id,
 2032            'secret_access_key': self.secret_access_key,
 2033            'secret_store_id': self.secret_store_id,
 2034            'tags': self.tags,
 2035        }
 2036
 2037    @classmethod
 2038    def from_dict(cls, d):
 2039        return cls(
 2040            access_key=d.get('access_key'),
 2041            bind_interface=d.get('bind_interface'),
 2042            certificate_authority=d.get('certificate_authority'),
 2043            cluster_name=d.get('cluster_name'),
 2044            egress_filter=d.get('egress_filter'),
 2045            endpoint=d.get('endpoint'),
 2046            healthcheck_namespace=d.get('healthcheck_namespace'),
 2047            healthy=d.get('healthy'),
 2048            id=d.get('id'),
 2049            name=d.get('name'),
 2050            region=d.get('region'),
 2051            role_arn=d.get('role_arn'),
 2052            role_external_id=d.get('role_external_id'),
 2053            secret_access_key=d.get('secret_access_key'),
 2054            secret_store_id=d.get('secret_store_id'),
 2055            tags=d.get('tags'),
 2056        )
 2057
 2058
 2059class AmazonES:
 2060    __slots__ = [
 2061        'access_key',
 2062        'bind_interface',
 2063        'egress_filter',
 2064        'endpoint',
 2065        'healthy',
 2066        'id',
 2067        'name',
 2068        'port_override',
 2069        'region',
 2070        'role_arn',
 2071        'role_external_id',
 2072        'secret_access_key',
 2073        'secret_store_id',
 2074        'tags',
 2075    ]
 2076
 2077    def __init__(
 2078        self,
 2079        access_key=None,
 2080        bind_interface=None,
 2081        egress_filter=None,
 2082        endpoint=None,
 2083        healthy=None,
 2084        id=None,
 2085        name=None,
 2086        port_override=None,
 2087        region=None,
 2088        role_arn=None,
 2089        role_external_id=None,
 2090        secret_access_key=None,
 2091        secret_store_id=None,
 2092        tags=None,
 2093    ):
 2094        self.access_key = access_key if access_key is not None else ''
 2095        self.bind_interface = bind_interface if bind_interface is not None else ''
 2096        '''
 2097         Bind interface
 2098        '''
 2099        self.egress_filter = egress_filter if egress_filter is not None else ''
 2100        '''
 2101         A filter applied to the routing logic to pin datasource to nodes.
 2102        '''
 2103        self.endpoint = endpoint if endpoint is not None else ''
 2104        self.healthy = healthy if healthy is not None else False
 2105        '''
 2106         True if the datasource is reachable and the credentials are valid.
 2107        '''
 2108        self.id = id if id is not None else ''
 2109        '''
 2110         Unique identifier of the Resource.
 2111        '''
 2112        self.name = name if name is not None else ''
 2113        '''
 2114         Unique human-readable name of the Resource.
 2115        '''
 2116        self.port_override = port_override if port_override is not None else 0
 2117        self.region = region if region is not None else ''
 2118        self.role_arn = role_arn if role_arn is not None else ''
 2119        self.role_external_id = role_external_id if role_external_id is not None else ''
 2120        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2121        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2122        '''
 2123         ID of the secret store containing credentials for this resource, if any.
 2124        '''
 2125        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2126        '''
 2127         Tags is a map of key, value pairs.
 2128        '''
 2129
 2130    def __repr__(self):
 2131        return '<sdm.AmazonES ' + \
 2132            'access_key: ' + repr(self.access_key) + ' ' +\
 2133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2135            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2136            'healthy: ' + repr(self.healthy) + ' ' +\
 2137            'id: ' + repr(self.id) + ' ' +\
 2138            'name: ' + repr(self.name) + ' ' +\
 2139            'port_override: ' + repr(self.port_override) + ' ' +\
 2140            'region: ' + repr(self.region) + ' ' +\
 2141            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2142            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2143            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2145            'tags: ' + repr(self.tags) + ' ' +\
 2146            '>'
 2147
 2148    def to_dict(self):
 2149        return {
 2150            'access_key': self.access_key,
 2151            'bind_interface': self.bind_interface,
 2152            'egress_filter': self.egress_filter,
 2153            'endpoint': self.endpoint,
 2154            'healthy': self.healthy,
 2155            'id': self.id,
 2156            'name': self.name,
 2157            'port_override': self.port_override,
 2158            'region': self.region,
 2159            'role_arn': self.role_arn,
 2160            'role_external_id': self.role_external_id,
 2161            'secret_access_key': self.secret_access_key,
 2162            'secret_store_id': self.secret_store_id,
 2163            'tags': self.tags,
 2164        }
 2165
 2166    @classmethod
 2167    def from_dict(cls, d):
 2168        return cls(
 2169            access_key=d.get('access_key'),
 2170            bind_interface=d.get('bind_interface'),
 2171            egress_filter=d.get('egress_filter'),
 2172            endpoint=d.get('endpoint'),
 2173            healthy=d.get('healthy'),
 2174            id=d.get('id'),
 2175            name=d.get('name'),
 2176            port_override=d.get('port_override'),
 2177            region=d.get('region'),
 2178            role_arn=d.get('role_arn'),
 2179            role_external_id=d.get('role_external_id'),
 2180            secret_access_key=d.get('secret_access_key'),
 2181            secret_store_id=d.get('secret_store_id'),
 2182            tags=d.get('tags'),
 2183        )
 2184
 2185
 2186class AmazonMQAMQP091:
 2187    __slots__ = [
 2188        'bind_interface',
 2189        'egress_filter',
 2190        'healthy',
 2191        'hostname',
 2192        'id',
 2193        'name',
 2194        'password',
 2195        'port',
 2196        'port_override',
 2197        'secret_store_id',
 2198        'tags',
 2199        'tls_required',
 2200        'username',
 2201    ]
 2202
 2203    def __init__(
 2204        self,
 2205        bind_interface=None,
 2206        egress_filter=None,
 2207        healthy=None,
 2208        hostname=None,
 2209        id=None,
 2210        name=None,
 2211        password=None,
 2212        port=None,
 2213        port_override=None,
 2214        secret_store_id=None,
 2215        tags=None,
 2216        tls_required=None,
 2217        username=None,
 2218    ):
 2219        self.bind_interface = bind_interface if bind_interface is not None else ''
 2220        '''
 2221         Bind interface
 2222        '''
 2223        self.egress_filter = egress_filter if egress_filter is not None else ''
 2224        '''
 2225         A filter applied to the routing logic to pin datasource to nodes.
 2226        '''
 2227        self.healthy = healthy if healthy is not None else False
 2228        '''
 2229         True if the datasource is reachable and the credentials are valid.
 2230        '''
 2231        self.hostname = hostname if hostname is not None else ''
 2232        self.id = id if id is not None else ''
 2233        '''
 2234         Unique identifier of the Resource.
 2235        '''
 2236        self.name = name if name is not None else ''
 2237        '''
 2238         Unique human-readable name of the Resource.
 2239        '''
 2240        self.password = password if password is not None else ''
 2241        self.port = port if port is not None else 0
 2242        self.port_override = port_override if port_override is not None else 0
 2243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2244        '''
 2245         ID of the secret store containing credentials for this resource, if any.
 2246        '''
 2247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2248        '''
 2249         Tags is a map of key, value pairs.
 2250        '''
 2251        self.tls_required = tls_required if tls_required is not None else False
 2252        self.username = username if username is not None else ''
 2253
 2254    def __repr__(self):
 2255        return '<sdm.AmazonMQAMQP091 ' + \
 2256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2257            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2258            'healthy: ' + repr(self.healthy) + ' ' +\
 2259            'hostname: ' + repr(self.hostname) + ' ' +\
 2260            'id: ' + repr(self.id) + ' ' +\
 2261            'name: ' + repr(self.name) + ' ' +\
 2262            'password: ' + repr(self.password) + ' ' +\
 2263            'port: ' + repr(self.port) + ' ' +\
 2264            'port_override: ' + repr(self.port_override) + ' ' +\
 2265            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2266            'tags: ' + repr(self.tags) + ' ' +\
 2267            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2268            'username: ' + repr(self.username) + ' ' +\
 2269            '>'
 2270
 2271    def to_dict(self):
 2272        return {
 2273            'bind_interface': self.bind_interface,
 2274            'egress_filter': self.egress_filter,
 2275            'healthy': self.healthy,
 2276            'hostname': self.hostname,
 2277            'id': self.id,
 2278            'name': self.name,
 2279            'password': self.password,
 2280            'port': self.port,
 2281            'port_override': self.port_override,
 2282            'secret_store_id': self.secret_store_id,
 2283            'tags': self.tags,
 2284            'tls_required': self.tls_required,
 2285            'username': self.username,
 2286        }
 2287
 2288    @classmethod
 2289    def from_dict(cls, d):
 2290        return cls(
 2291            bind_interface=d.get('bind_interface'),
 2292            egress_filter=d.get('egress_filter'),
 2293            healthy=d.get('healthy'),
 2294            hostname=d.get('hostname'),
 2295            id=d.get('id'),
 2296            name=d.get('name'),
 2297            password=d.get('password'),
 2298            port=d.get('port'),
 2299            port_override=d.get('port_override'),
 2300            secret_store_id=d.get('secret_store_id'),
 2301            tags=d.get('tags'),
 2302            tls_required=d.get('tls_required'),
 2303            username=d.get('username'),
 2304        )
 2305
 2306
 2307class Athena:
 2308    __slots__ = [
 2309        'access_key',
 2310        'bind_interface',
 2311        'egress_filter',
 2312        'healthy',
 2313        'id',
 2314        'name',
 2315        'output',
 2316        'port_override',
 2317        'region',
 2318        'role_arn',
 2319        'role_external_id',
 2320        'secret_access_key',
 2321        'secret_store_id',
 2322        'tags',
 2323    ]
 2324
 2325    def __init__(
 2326        self,
 2327        access_key=None,
 2328        bind_interface=None,
 2329        egress_filter=None,
 2330        healthy=None,
 2331        id=None,
 2332        name=None,
 2333        output=None,
 2334        port_override=None,
 2335        region=None,
 2336        role_arn=None,
 2337        role_external_id=None,
 2338        secret_access_key=None,
 2339        secret_store_id=None,
 2340        tags=None,
 2341    ):
 2342        self.access_key = access_key if access_key is not None else ''
 2343        self.bind_interface = bind_interface if bind_interface is not None else ''
 2344        '''
 2345         Bind interface
 2346        '''
 2347        self.egress_filter = egress_filter if egress_filter is not None else ''
 2348        '''
 2349         A filter applied to the routing logic to pin datasource to nodes.
 2350        '''
 2351        self.healthy = healthy if healthy is not None else False
 2352        '''
 2353         True if the datasource is reachable and the credentials are valid.
 2354        '''
 2355        self.id = id if id is not None else ''
 2356        '''
 2357         Unique identifier of the Resource.
 2358        '''
 2359        self.name = name if name is not None else ''
 2360        '''
 2361         Unique human-readable name of the Resource.
 2362        '''
 2363        self.output = output if output is not None else ''
 2364        self.port_override = port_override if port_override is not None else 0
 2365        self.region = region if region is not None else ''
 2366        self.role_arn = role_arn if role_arn is not None else ''
 2367        self.role_external_id = role_external_id if role_external_id is not None else ''
 2368        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2370        '''
 2371         ID of the secret store containing credentials for this resource, if any.
 2372        '''
 2373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2374        '''
 2375         Tags is a map of key, value pairs.
 2376        '''
 2377
 2378    def __repr__(self):
 2379        return '<sdm.Athena ' + \
 2380            'access_key: ' + repr(self.access_key) + ' ' +\
 2381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2383            'healthy: ' + repr(self.healthy) + ' ' +\
 2384            'id: ' + repr(self.id) + ' ' +\
 2385            'name: ' + repr(self.name) + ' ' +\
 2386            'output: ' + repr(self.output) + ' ' +\
 2387            'port_override: ' + repr(self.port_override) + ' ' +\
 2388            'region: ' + repr(self.region) + ' ' +\
 2389            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2390            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2391            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2392            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2393            'tags: ' + repr(self.tags) + ' ' +\
 2394            '>'
 2395
 2396    def to_dict(self):
 2397        return {
 2398            'access_key': self.access_key,
 2399            'bind_interface': self.bind_interface,
 2400            'egress_filter': self.egress_filter,
 2401            'healthy': self.healthy,
 2402            'id': self.id,
 2403            'name': self.name,
 2404            'output': self.output,
 2405            'port_override': self.port_override,
 2406            'region': self.region,
 2407            'role_arn': self.role_arn,
 2408            'role_external_id': self.role_external_id,
 2409            'secret_access_key': self.secret_access_key,
 2410            'secret_store_id': self.secret_store_id,
 2411            'tags': self.tags,
 2412        }
 2413
 2414    @classmethod
 2415    def from_dict(cls, d):
 2416        return cls(
 2417            access_key=d.get('access_key'),
 2418            bind_interface=d.get('bind_interface'),
 2419            egress_filter=d.get('egress_filter'),
 2420            healthy=d.get('healthy'),
 2421            id=d.get('id'),
 2422            name=d.get('name'),
 2423            output=d.get('output'),
 2424            port_override=d.get('port_override'),
 2425            region=d.get('region'),
 2426            role_arn=d.get('role_arn'),
 2427            role_external_id=d.get('role_external_id'),
 2428            secret_access_key=d.get('secret_access_key'),
 2429            secret_store_id=d.get('secret_store_id'),
 2430            tags=d.get('tags'),
 2431        )
 2432
 2433
 2434class AuroraMysql:
 2435    __slots__ = [
 2436        'bind_interface',
 2437        'database',
 2438        'egress_filter',
 2439        'healthy',
 2440        'hostname',
 2441        'id',
 2442        'name',
 2443        'password',
 2444        'port',
 2445        'port_override',
 2446        'secret_store_id',
 2447        'tags',
 2448        'username',
 2449    ]
 2450
 2451    def __init__(
 2452        self,
 2453        bind_interface=None,
 2454        database=None,
 2455        egress_filter=None,
 2456        healthy=None,
 2457        hostname=None,
 2458        id=None,
 2459        name=None,
 2460        password=None,
 2461        port=None,
 2462        port_override=None,
 2463        secret_store_id=None,
 2464        tags=None,
 2465        username=None,
 2466    ):
 2467        self.bind_interface = bind_interface if bind_interface is not None else ''
 2468        '''
 2469         Bind interface
 2470        '''
 2471        self.database = database if database is not None else ''
 2472        self.egress_filter = egress_filter if egress_filter is not None else ''
 2473        '''
 2474         A filter applied to the routing logic to pin datasource to nodes.
 2475        '''
 2476        self.healthy = healthy if healthy is not None else False
 2477        '''
 2478         True if the datasource is reachable and the credentials are valid.
 2479        '''
 2480        self.hostname = hostname if hostname is not None else ''
 2481        self.id = id if id is not None else ''
 2482        '''
 2483         Unique identifier of the Resource.
 2484        '''
 2485        self.name = name if name is not None else ''
 2486        '''
 2487         Unique human-readable name of the Resource.
 2488        '''
 2489        self.password = password if password is not None else ''
 2490        self.port = port if port is not None else 0
 2491        self.port_override = port_override if port_override is not None else 0
 2492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2493        '''
 2494         ID of the secret store containing credentials for this resource, if any.
 2495        '''
 2496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2497        '''
 2498         Tags is a map of key, value pairs.
 2499        '''
 2500        self.username = username if username is not None else ''
 2501
 2502    def __repr__(self):
 2503        return '<sdm.AuroraMysql ' + \
 2504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2505            'database: ' + repr(self.database) + ' ' +\
 2506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2507            'healthy: ' + repr(self.healthy) + ' ' +\
 2508            'hostname: ' + repr(self.hostname) + ' ' +\
 2509            'id: ' + repr(self.id) + ' ' +\
 2510            'name: ' + repr(self.name) + ' ' +\
 2511            'password: ' + repr(self.password) + ' ' +\
 2512            'port: ' + repr(self.port) + ' ' +\
 2513            'port_override: ' + repr(self.port_override) + ' ' +\
 2514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2515            'tags: ' + repr(self.tags) + ' ' +\
 2516            'username: ' + repr(self.username) + ' ' +\
 2517            '>'
 2518
 2519    def to_dict(self):
 2520        return {
 2521            'bind_interface': self.bind_interface,
 2522            'database': self.database,
 2523            'egress_filter': self.egress_filter,
 2524            'healthy': self.healthy,
 2525            'hostname': self.hostname,
 2526            'id': self.id,
 2527            'name': self.name,
 2528            'password': self.password,
 2529            'port': self.port,
 2530            'port_override': self.port_override,
 2531            'secret_store_id': self.secret_store_id,
 2532            'tags': self.tags,
 2533            'username': self.username,
 2534        }
 2535
 2536    @classmethod
 2537    def from_dict(cls, d):
 2538        return cls(
 2539            bind_interface=d.get('bind_interface'),
 2540            database=d.get('database'),
 2541            egress_filter=d.get('egress_filter'),
 2542            healthy=d.get('healthy'),
 2543            hostname=d.get('hostname'),
 2544            id=d.get('id'),
 2545            name=d.get('name'),
 2546            password=d.get('password'),
 2547            port=d.get('port'),
 2548            port_override=d.get('port_override'),
 2549            secret_store_id=d.get('secret_store_id'),
 2550            tags=d.get('tags'),
 2551            username=d.get('username'),
 2552        )
 2553
 2554
 2555class AuroraPostgres:
 2556    __slots__ = [
 2557        'bind_interface',
 2558        'database',
 2559        'egress_filter',
 2560        'healthy',
 2561        'hostname',
 2562        'id',
 2563        'name',
 2564        'override_database',
 2565        'password',
 2566        'port',
 2567        'port_override',
 2568        'secret_store_id',
 2569        'tags',
 2570        'username',
 2571    ]
 2572
 2573    def __init__(
 2574        self,
 2575        bind_interface=None,
 2576        database=None,
 2577        egress_filter=None,
 2578        healthy=None,
 2579        hostname=None,
 2580        id=None,
 2581        name=None,
 2582        override_database=None,
 2583        password=None,
 2584        port=None,
 2585        port_override=None,
 2586        secret_store_id=None,
 2587        tags=None,
 2588        username=None,
 2589    ):
 2590        self.bind_interface = bind_interface if bind_interface is not None else ''
 2591        '''
 2592         Bind interface
 2593        '''
 2594        self.database = database if database is not None else ''
 2595        self.egress_filter = egress_filter if egress_filter is not None else ''
 2596        '''
 2597         A filter applied to the routing logic to pin datasource to nodes.
 2598        '''
 2599        self.healthy = healthy if healthy is not None else False
 2600        '''
 2601         True if the datasource is reachable and the credentials are valid.
 2602        '''
 2603        self.hostname = hostname if hostname is not None else ''
 2604        self.id = id if id is not None else ''
 2605        '''
 2606         Unique identifier of the Resource.
 2607        '''
 2608        self.name = name if name is not None else ''
 2609        '''
 2610         Unique human-readable name of the Resource.
 2611        '''
 2612        self.override_database = override_database if override_database is not None else False
 2613        self.password = password if password is not None else ''
 2614        self.port = port if port is not None else 0
 2615        self.port_override = port_override if port_override is not None else 0
 2616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2617        '''
 2618         ID of the secret store containing credentials for this resource, if any.
 2619        '''
 2620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2621        '''
 2622         Tags is a map of key, value pairs.
 2623        '''
 2624        self.username = username if username is not None else ''
 2625
 2626    def __repr__(self):
 2627        return '<sdm.AuroraPostgres ' + \
 2628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2629            'database: ' + repr(self.database) + ' ' +\
 2630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2631            'healthy: ' + repr(self.healthy) + ' ' +\
 2632            'hostname: ' + repr(self.hostname) + ' ' +\
 2633            'id: ' + repr(self.id) + ' ' +\
 2634            'name: ' + repr(self.name) + ' ' +\
 2635            'override_database: ' + repr(self.override_database) + ' ' +\
 2636            'password: ' + repr(self.password) + ' ' +\
 2637            'port: ' + repr(self.port) + ' ' +\
 2638            'port_override: ' + repr(self.port_override) + ' ' +\
 2639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2640            'tags: ' + repr(self.tags) + ' ' +\
 2641            'username: ' + repr(self.username) + ' ' +\
 2642            '>'
 2643
 2644    def to_dict(self):
 2645        return {
 2646            'bind_interface': self.bind_interface,
 2647            'database': self.database,
 2648            'egress_filter': self.egress_filter,
 2649            'healthy': self.healthy,
 2650            'hostname': self.hostname,
 2651            'id': self.id,
 2652            'name': self.name,
 2653            'override_database': self.override_database,
 2654            'password': self.password,
 2655            'port': self.port,
 2656            'port_override': self.port_override,
 2657            'secret_store_id': self.secret_store_id,
 2658            'tags': self.tags,
 2659            'username': self.username,
 2660        }
 2661
 2662    @classmethod
 2663    def from_dict(cls, d):
 2664        return cls(
 2665            bind_interface=d.get('bind_interface'),
 2666            database=d.get('database'),
 2667            egress_filter=d.get('egress_filter'),
 2668            healthy=d.get('healthy'),
 2669            hostname=d.get('hostname'),
 2670            id=d.get('id'),
 2671            name=d.get('name'),
 2672            override_database=d.get('override_database'),
 2673            password=d.get('password'),
 2674            port=d.get('port'),
 2675            port_override=d.get('port_override'),
 2676            secret_store_id=d.get('secret_store_id'),
 2677            tags=d.get('tags'),
 2678            username=d.get('username'),
 2679        )
 2680
 2681
 2682class Azure:
 2683    __slots__ = [
 2684        'app_id',
 2685        'bind_interface',
 2686        'egress_filter',
 2687        'healthy',
 2688        'id',
 2689        'name',
 2690        'password',
 2691        'secret_store_id',
 2692        'tags',
 2693        'tenant_id',
 2694    ]
 2695
 2696    def __init__(
 2697        self,
 2698        app_id=None,
 2699        bind_interface=None,
 2700        egress_filter=None,
 2701        healthy=None,
 2702        id=None,
 2703        name=None,
 2704        password=None,
 2705        secret_store_id=None,
 2706        tags=None,
 2707        tenant_id=None,
 2708    ):
 2709        self.app_id = app_id if app_id is not None else ''
 2710        self.bind_interface = bind_interface if bind_interface is not None else ''
 2711        '''
 2712         Bind interface
 2713        '''
 2714        self.egress_filter = egress_filter if egress_filter is not None else ''
 2715        '''
 2716         A filter applied to the routing logic to pin datasource to nodes.
 2717        '''
 2718        self.healthy = healthy if healthy is not None else False
 2719        '''
 2720         True if the datasource is reachable and the credentials are valid.
 2721        '''
 2722        self.id = id if id is not None else ''
 2723        '''
 2724         Unique identifier of the Resource.
 2725        '''
 2726        self.name = name if name is not None else ''
 2727        '''
 2728         Unique human-readable name of the Resource.
 2729        '''
 2730        self.password = password if password is not None else ''
 2731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2732        '''
 2733         ID of the secret store containing credentials for this resource, if any.
 2734        '''
 2735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2736        '''
 2737         Tags is a map of key, value pairs.
 2738        '''
 2739        self.tenant_id = tenant_id if tenant_id is not None else ''
 2740
 2741    def __repr__(self):
 2742        return '<sdm.Azure ' + \
 2743            'app_id: ' + repr(self.app_id) + ' ' +\
 2744            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2745            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2746            'healthy: ' + repr(self.healthy) + ' ' +\
 2747            'id: ' + repr(self.id) + ' ' +\
 2748            'name: ' + repr(self.name) + ' ' +\
 2749            'password: ' + repr(self.password) + ' ' +\
 2750            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2751            'tags: ' + repr(self.tags) + ' ' +\
 2752            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2753            '>'
 2754
 2755    def to_dict(self):
 2756        return {
 2757            'app_id': self.app_id,
 2758            'bind_interface': self.bind_interface,
 2759            'egress_filter': self.egress_filter,
 2760            'healthy': self.healthy,
 2761            'id': self.id,
 2762            'name': self.name,
 2763            'password': self.password,
 2764            'secret_store_id': self.secret_store_id,
 2765            'tags': self.tags,
 2766            'tenant_id': self.tenant_id,
 2767        }
 2768
 2769    @classmethod
 2770    def from_dict(cls, d):
 2771        return cls(
 2772            app_id=d.get('app_id'),
 2773            bind_interface=d.get('bind_interface'),
 2774            egress_filter=d.get('egress_filter'),
 2775            healthy=d.get('healthy'),
 2776            id=d.get('id'),
 2777            name=d.get('name'),
 2778            password=d.get('password'),
 2779            secret_store_id=d.get('secret_store_id'),
 2780            tags=d.get('tags'),
 2781            tenant_id=d.get('tenant_id'),
 2782        )
 2783
 2784
 2785class AzureCertificate:
 2786    __slots__ = [
 2787        'app_id',
 2788        'bind_interface',
 2789        'client_certificate',
 2790        'egress_filter',
 2791        'healthy',
 2792        'id',
 2793        'name',
 2794        'secret_store_id',
 2795        'tags',
 2796        'tenant_id',
 2797    ]
 2798
 2799    def __init__(
 2800        self,
 2801        app_id=None,
 2802        bind_interface=None,
 2803        client_certificate=None,
 2804        egress_filter=None,
 2805        healthy=None,
 2806        id=None,
 2807        name=None,
 2808        secret_store_id=None,
 2809        tags=None,
 2810        tenant_id=None,
 2811    ):
 2812        self.app_id = app_id if app_id is not None else ''
 2813        self.bind_interface = bind_interface if bind_interface is not None else ''
 2814        '''
 2815         Bind interface
 2816        '''
 2817        self.client_certificate = client_certificate if client_certificate is not None else ''
 2818        self.egress_filter = egress_filter if egress_filter is not None else ''
 2819        '''
 2820         A filter applied to the routing logic to pin datasource to nodes.
 2821        '''
 2822        self.healthy = healthy if healthy is not None else False
 2823        '''
 2824         True if the datasource is reachable and the credentials are valid.
 2825        '''
 2826        self.id = id if id is not None else ''
 2827        '''
 2828         Unique identifier of the Resource.
 2829        '''
 2830        self.name = name if name is not None else ''
 2831        '''
 2832         Unique human-readable name of the Resource.
 2833        '''
 2834        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2835        '''
 2836         ID of the secret store containing credentials for this resource, if any.
 2837        '''
 2838        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2839        '''
 2840         Tags is a map of key, value pairs.
 2841        '''
 2842        self.tenant_id = tenant_id if tenant_id is not None else ''
 2843
 2844    def __repr__(self):
 2845        return '<sdm.AzureCertificate ' + \
 2846            'app_id: ' + repr(self.app_id) + ' ' +\
 2847            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2848            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2849            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2850            'healthy: ' + repr(self.healthy) + ' ' +\
 2851            'id: ' + repr(self.id) + ' ' +\
 2852            'name: ' + repr(self.name) + ' ' +\
 2853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2854            'tags: ' + repr(self.tags) + ' ' +\
 2855            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2856            '>'
 2857
 2858    def to_dict(self):
 2859        return {
 2860            'app_id': self.app_id,
 2861            'bind_interface': self.bind_interface,
 2862            'client_certificate': self.client_certificate,
 2863            'egress_filter': self.egress_filter,
 2864            'healthy': self.healthy,
 2865            'id': self.id,
 2866            'name': self.name,
 2867            'secret_store_id': self.secret_store_id,
 2868            'tags': self.tags,
 2869            'tenant_id': self.tenant_id,
 2870        }
 2871
 2872    @classmethod
 2873    def from_dict(cls, d):
 2874        return cls(
 2875            app_id=d.get('app_id'),
 2876            bind_interface=d.get('bind_interface'),
 2877            client_certificate=d.get('client_certificate'),
 2878            egress_filter=d.get('egress_filter'),
 2879            healthy=d.get('healthy'),
 2880            id=d.get('id'),
 2881            name=d.get('name'),
 2882            secret_store_id=d.get('secret_store_id'),
 2883            tags=d.get('tags'),
 2884            tenant_id=d.get('tenant_id'),
 2885        )
 2886
 2887
 2888class AzurePostgres:
 2889    __slots__ = [
 2890        'bind_interface',
 2891        'database',
 2892        'egress_filter',
 2893        'healthy',
 2894        'hostname',
 2895        'id',
 2896        'name',
 2897        'override_database',
 2898        'password',
 2899        'port',
 2900        'port_override',
 2901        'secret_store_id',
 2902        'tags',
 2903        'username',
 2904    ]
 2905
 2906    def __init__(
 2907        self,
 2908        bind_interface=None,
 2909        database=None,
 2910        egress_filter=None,
 2911        healthy=None,
 2912        hostname=None,
 2913        id=None,
 2914        name=None,
 2915        override_database=None,
 2916        password=None,
 2917        port=None,
 2918        port_override=None,
 2919        secret_store_id=None,
 2920        tags=None,
 2921        username=None,
 2922    ):
 2923        self.bind_interface = bind_interface if bind_interface is not None else ''
 2924        '''
 2925         Bind interface
 2926        '''
 2927        self.database = database if database is not None else ''
 2928        self.egress_filter = egress_filter if egress_filter is not None else ''
 2929        '''
 2930         A filter applied to the routing logic to pin datasource to nodes.
 2931        '''
 2932        self.healthy = healthy if healthy is not None else False
 2933        '''
 2934         True if the datasource is reachable and the credentials are valid.
 2935        '''
 2936        self.hostname = hostname if hostname is not None else ''
 2937        self.id = id if id is not None else ''
 2938        '''
 2939         Unique identifier of the Resource.
 2940        '''
 2941        self.name = name if name is not None else ''
 2942        '''
 2943         Unique human-readable name of the Resource.
 2944        '''
 2945        self.override_database = override_database if override_database is not None else False
 2946        self.password = password if password is not None else ''
 2947        self.port = port if port is not None else 0
 2948        self.port_override = port_override if port_override is not None else 0
 2949        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2950        '''
 2951         ID of the secret store containing credentials for this resource, if any.
 2952        '''
 2953        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2954        '''
 2955         Tags is a map of key, value pairs.
 2956        '''
 2957        self.username = username if username is not None else ''
 2958
 2959    def __repr__(self):
 2960        return '<sdm.AzurePostgres ' + \
 2961            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2962            'database: ' + repr(self.database) + ' ' +\
 2963            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2964            'healthy: ' + repr(self.healthy) + ' ' +\
 2965            'hostname: ' + repr(self.hostname) + ' ' +\
 2966            'id: ' + repr(self.id) + ' ' +\
 2967            'name: ' + repr(self.name) + ' ' +\
 2968            'override_database: ' + repr(self.override_database) + ' ' +\
 2969            'password: ' + repr(self.password) + ' ' +\
 2970            'port: ' + repr(self.port) + ' ' +\
 2971            'port_override: ' + repr(self.port_override) + ' ' +\
 2972            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2973            'tags: ' + repr(self.tags) + ' ' +\
 2974            'username: ' + repr(self.username) + ' ' +\
 2975            '>'
 2976
 2977    def to_dict(self):
 2978        return {
 2979            'bind_interface': self.bind_interface,
 2980            'database': self.database,
 2981            'egress_filter': self.egress_filter,
 2982            'healthy': self.healthy,
 2983            'hostname': self.hostname,
 2984            'id': self.id,
 2985            'name': self.name,
 2986            'override_database': self.override_database,
 2987            'password': self.password,
 2988            'port': self.port,
 2989            'port_override': self.port_override,
 2990            'secret_store_id': self.secret_store_id,
 2991            'tags': self.tags,
 2992            'username': self.username,
 2993        }
 2994
 2995    @classmethod
 2996    def from_dict(cls, d):
 2997        return cls(
 2998            bind_interface=d.get('bind_interface'),
 2999            database=d.get('database'),
 3000            egress_filter=d.get('egress_filter'),
 3001            healthy=d.get('healthy'),
 3002            hostname=d.get('hostname'),
 3003            id=d.get('id'),
 3004            name=d.get('name'),
 3005            override_database=d.get('override_database'),
 3006            password=d.get('password'),
 3007            port=d.get('port'),
 3008            port_override=d.get('port_override'),
 3009            secret_store_id=d.get('secret_store_id'),
 3010            tags=d.get('tags'),
 3011            username=d.get('username'),
 3012        )
 3013
 3014
 3015class AzureStore:
 3016    __slots__ = [
 3017        'id',
 3018        'name',
 3019        'tags',
 3020        'vault_uri',
 3021    ]
 3022
 3023    def __init__(
 3024        self,
 3025        id=None,
 3026        name=None,
 3027        tags=None,
 3028        vault_uri=None,
 3029    ):
 3030        self.id = id if id is not None else ''
 3031        '''
 3032         Unique identifier of the SecretStore.
 3033        '''
 3034        self.name = name if name is not None else ''
 3035        '''
 3036         Unique human-readable name of the SecretStore.
 3037        '''
 3038        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3039        '''
 3040         Tags is a map of key, value pairs.
 3041        '''
 3042        self.vault_uri = vault_uri if vault_uri is not None else ''
 3043
 3044    def __repr__(self):
 3045        return '<sdm.AzureStore ' + \
 3046            'id: ' + repr(self.id) + ' ' +\
 3047            'name: ' + repr(self.name) + ' ' +\
 3048            'tags: ' + repr(self.tags) + ' ' +\
 3049            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3050            '>'
 3051
 3052    def to_dict(self):
 3053        return {
 3054            'id': self.id,
 3055            'name': self.name,
 3056            'tags': self.tags,
 3057            'vault_uri': self.vault_uri,
 3058        }
 3059
 3060    @classmethod
 3061    def from_dict(cls, d):
 3062        return cls(
 3063            id=d.get('id'),
 3064            name=d.get('name'),
 3065            tags=d.get('tags'),
 3066            vault_uri=d.get('vault_uri'),
 3067        )
 3068
 3069
 3070class BigQuery:
 3071    __slots__ = [
 3072        'bind_interface',
 3073        'egress_filter',
 3074        'endpoint',
 3075        'healthy',
 3076        'id',
 3077        'name',
 3078        'port_override',
 3079        'private_key',
 3080        'project',
 3081        'secret_store_id',
 3082        'tags',
 3083        'username',
 3084    ]
 3085
 3086    def __init__(
 3087        self,
 3088        bind_interface=None,
 3089        egress_filter=None,
 3090        endpoint=None,
 3091        healthy=None,
 3092        id=None,
 3093        name=None,
 3094        port_override=None,
 3095        private_key=None,
 3096        project=None,
 3097        secret_store_id=None,
 3098        tags=None,
 3099        username=None,
 3100    ):
 3101        self.bind_interface = bind_interface if bind_interface is not None else ''
 3102        '''
 3103         Bind interface
 3104        '''
 3105        self.egress_filter = egress_filter if egress_filter is not None else ''
 3106        '''
 3107         A filter applied to the routing logic to pin datasource to nodes.
 3108        '''
 3109        self.endpoint = endpoint if endpoint is not None else ''
 3110        self.healthy = healthy if healthy is not None else False
 3111        '''
 3112         True if the datasource is reachable and the credentials are valid.
 3113        '''
 3114        self.id = id if id is not None else ''
 3115        '''
 3116         Unique identifier of the Resource.
 3117        '''
 3118        self.name = name if name is not None else ''
 3119        '''
 3120         Unique human-readable name of the Resource.
 3121        '''
 3122        self.port_override = port_override if port_override is not None else 0
 3123        self.private_key = private_key if private_key is not None else ''
 3124        self.project = project if project is not None else ''
 3125        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3126        '''
 3127         ID of the secret store containing credentials for this resource, if any.
 3128        '''
 3129        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3130        '''
 3131         Tags is a map of key, value pairs.
 3132        '''
 3133        self.username = username if username is not None else ''
 3134
 3135    def __repr__(self):
 3136        return '<sdm.BigQuery ' + \
 3137            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3138            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3139            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3140            'healthy: ' + repr(self.healthy) + ' ' +\
 3141            'id: ' + repr(self.id) + ' ' +\
 3142            'name: ' + repr(self.name) + ' ' +\
 3143            'port_override: ' + repr(self.port_override) + ' ' +\
 3144            'private_key: ' + repr(self.private_key) + ' ' +\
 3145            'project: ' + repr(self.project) + ' ' +\
 3146            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3147            'tags: ' + repr(self.tags) + ' ' +\
 3148            'username: ' + repr(self.username) + ' ' +\
 3149            '>'
 3150
 3151    def to_dict(self):
 3152        return {
 3153            'bind_interface': self.bind_interface,
 3154            'egress_filter': self.egress_filter,
 3155            'endpoint': self.endpoint,
 3156            'healthy': self.healthy,
 3157            'id': self.id,
 3158            'name': self.name,
 3159            'port_override': self.port_override,
 3160            'private_key': self.private_key,
 3161            'project': self.project,
 3162            'secret_store_id': self.secret_store_id,
 3163            'tags': self.tags,
 3164            'username': self.username,
 3165        }
 3166
 3167    @classmethod
 3168    def from_dict(cls, d):
 3169        return cls(
 3170            bind_interface=d.get('bind_interface'),
 3171            egress_filter=d.get('egress_filter'),
 3172            endpoint=d.get('endpoint'),
 3173            healthy=d.get('healthy'),
 3174            id=d.get('id'),
 3175            name=d.get('name'),
 3176            port_override=d.get('port_override'),
 3177            private_key=d.get('private_key'),
 3178            project=d.get('project'),
 3179            secret_store_id=d.get('secret_store_id'),
 3180            tags=d.get('tags'),
 3181            username=d.get('username'),
 3182        )
 3183
 3184
 3185class Cassandra:
 3186    __slots__ = [
 3187        'bind_interface',
 3188        'egress_filter',
 3189        'healthy',
 3190        'hostname',
 3191        'id',
 3192        'name',
 3193        'password',
 3194        'port',
 3195        'port_override',
 3196        'secret_store_id',
 3197        'tags',
 3198        'tls_required',
 3199        'username',
 3200    ]
 3201
 3202    def __init__(
 3203        self,
 3204        bind_interface=None,
 3205        egress_filter=None,
 3206        healthy=None,
 3207        hostname=None,
 3208        id=None,
 3209        name=None,
 3210        password=None,
 3211        port=None,
 3212        port_override=None,
 3213        secret_store_id=None,
 3214        tags=None,
 3215        tls_required=None,
 3216        username=None,
 3217    ):
 3218        self.bind_interface = bind_interface if bind_interface is not None else ''
 3219        '''
 3220         Bind interface
 3221        '''
 3222        self.egress_filter = egress_filter if egress_filter is not None else ''
 3223        '''
 3224         A filter applied to the routing logic to pin datasource to nodes.
 3225        '''
 3226        self.healthy = healthy if healthy is not None else False
 3227        '''
 3228         True if the datasource is reachable and the credentials are valid.
 3229        '''
 3230        self.hostname = hostname if hostname is not None else ''
 3231        self.id = id if id is not None else ''
 3232        '''
 3233         Unique identifier of the Resource.
 3234        '''
 3235        self.name = name if name is not None else ''
 3236        '''
 3237         Unique human-readable name of the Resource.
 3238        '''
 3239        self.password = password if password is not None else ''
 3240        self.port = port if port is not None else 0
 3241        self.port_override = port_override if port_override is not None else 0
 3242        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3243        '''
 3244         ID of the secret store containing credentials for this resource, if any.
 3245        '''
 3246        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3247        '''
 3248         Tags is a map of key, value pairs.
 3249        '''
 3250        self.tls_required = tls_required if tls_required is not None else False
 3251        self.username = username if username is not None else ''
 3252
 3253    def __repr__(self):
 3254        return '<sdm.Cassandra ' + \
 3255            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3256            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3257            'healthy: ' + repr(self.healthy) + ' ' +\
 3258            'hostname: ' + repr(self.hostname) + ' ' +\
 3259            'id: ' + repr(self.id) + ' ' +\
 3260            'name: ' + repr(self.name) + ' ' +\
 3261            'password: ' + repr(self.password) + ' ' +\
 3262            'port: ' + repr(self.port) + ' ' +\
 3263            'port_override: ' + repr(self.port_override) + ' ' +\
 3264            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3265            'tags: ' + repr(self.tags) + ' ' +\
 3266            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3267            'username: ' + repr(self.username) + ' ' +\
 3268            '>'
 3269
 3270    def to_dict(self):
 3271        return {
 3272            'bind_interface': self.bind_interface,
 3273            'egress_filter': self.egress_filter,
 3274            'healthy': self.healthy,
 3275            'hostname': self.hostname,
 3276            'id': self.id,
 3277            'name': self.name,
 3278            'password': self.password,
 3279            'port': self.port,
 3280            'port_override': self.port_override,
 3281            'secret_store_id': self.secret_store_id,
 3282            'tags': self.tags,
 3283            'tls_required': self.tls_required,
 3284            'username': self.username,
 3285        }
 3286
 3287    @classmethod
 3288    def from_dict(cls, d):
 3289        return cls(
 3290            bind_interface=d.get('bind_interface'),
 3291            egress_filter=d.get('egress_filter'),
 3292            healthy=d.get('healthy'),
 3293            hostname=d.get('hostname'),
 3294            id=d.get('id'),
 3295            name=d.get('name'),
 3296            password=d.get('password'),
 3297            port=d.get('port'),
 3298            port_override=d.get('port_override'),
 3299            secret_store_id=d.get('secret_store_id'),
 3300            tags=d.get('tags'),
 3301            tls_required=d.get('tls_required'),
 3302            username=d.get('username'),
 3303        )
 3304
 3305
 3306class Citus:
 3307    __slots__ = [
 3308        'bind_interface',
 3309        'database',
 3310        'egress_filter',
 3311        'healthy',
 3312        'hostname',
 3313        'id',
 3314        'name',
 3315        'override_database',
 3316        'password',
 3317        'port',
 3318        'port_override',
 3319        'secret_store_id',
 3320        'tags',
 3321        'username',
 3322    ]
 3323
 3324    def __init__(
 3325        self,
 3326        bind_interface=None,
 3327        database=None,
 3328        egress_filter=None,
 3329        healthy=None,
 3330        hostname=None,
 3331        id=None,
 3332        name=None,
 3333        override_database=None,
 3334        password=None,
 3335        port=None,
 3336        port_override=None,
 3337        secret_store_id=None,
 3338        tags=None,
 3339        username=None,
 3340    ):
 3341        self.bind_interface = bind_interface if bind_interface is not None else ''
 3342        '''
 3343         Bind interface
 3344        '''
 3345        self.database = database if database is not None else ''
 3346        self.egress_filter = egress_filter if egress_filter is not None else ''
 3347        '''
 3348         A filter applied to the routing logic to pin datasource to nodes.
 3349        '''
 3350        self.healthy = healthy if healthy is not None else False
 3351        '''
 3352         True if the datasource is reachable and the credentials are valid.
 3353        '''
 3354        self.hostname = hostname if hostname is not None else ''
 3355        self.id = id if id is not None else ''
 3356        '''
 3357         Unique identifier of the Resource.
 3358        '''
 3359        self.name = name if name is not None else ''
 3360        '''
 3361         Unique human-readable name of the Resource.
 3362        '''
 3363        self.override_database = override_database if override_database is not None else False
 3364        self.password = password if password is not None else ''
 3365        self.port = port if port is not None else 0
 3366        self.port_override = port_override if port_override is not None else 0
 3367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3368        '''
 3369         ID of the secret store containing credentials for this resource, if any.
 3370        '''
 3371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3372        '''
 3373         Tags is a map of key, value pairs.
 3374        '''
 3375        self.username = username if username is not None else ''
 3376
 3377    def __repr__(self):
 3378        return '<sdm.Citus ' + \
 3379            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3380            'database: ' + repr(self.database) + ' ' +\
 3381            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3382            'healthy: ' + repr(self.healthy) + ' ' +\
 3383            'hostname: ' + repr(self.hostname) + ' ' +\
 3384            'id: ' + repr(self.id) + ' ' +\
 3385            'name: ' + repr(self.name) + ' ' +\
 3386            'override_database: ' + repr(self.override_database) + ' ' +\
 3387            'password: ' + repr(self.password) + ' ' +\
 3388            'port: ' + repr(self.port) + ' ' +\
 3389            'port_override: ' + repr(self.port_override) + ' ' +\
 3390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3391            'tags: ' + repr(self.tags) + ' ' +\
 3392            'username: ' + repr(self.username) + ' ' +\
 3393            '>'
 3394
 3395    def to_dict(self):
 3396        return {
 3397            'bind_interface': self.bind_interface,
 3398            'database': self.database,
 3399            'egress_filter': self.egress_filter,
 3400            'healthy': self.healthy,
 3401            'hostname': self.hostname,
 3402            'id': self.id,
 3403            'name': self.name,
 3404            'override_database': self.override_database,
 3405            'password': self.password,
 3406            'port': self.port,
 3407            'port_override': self.port_override,
 3408            'secret_store_id': self.secret_store_id,
 3409            'tags': self.tags,
 3410            'username': self.username,
 3411        }
 3412
 3413    @classmethod
 3414    def from_dict(cls, d):
 3415        return cls(
 3416            bind_interface=d.get('bind_interface'),
 3417            database=d.get('database'),
 3418            egress_filter=d.get('egress_filter'),
 3419            healthy=d.get('healthy'),
 3420            hostname=d.get('hostname'),
 3421            id=d.get('id'),
 3422            name=d.get('name'),
 3423            override_database=d.get('override_database'),
 3424            password=d.get('password'),
 3425            port=d.get('port'),
 3426            port_override=d.get('port_override'),
 3427            secret_store_id=d.get('secret_store_id'),
 3428            tags=d.get('tags'),
 3429            username=d.get('username'),
 3430        )
 3431
 3432
 3433class Clustrix:
 3434    __slots__ = [
 3435        'bind_interface',
 3436        'database',
 3437        'egress_filter',
 3438        'healthy',
 3439        'hostname',
 3440        'id',
 3441        'name',
 3442        'password',
 3443        'port',
 3444        'port_override',
 3445        'secret_store_id',
 3446        'tags',
 3447        'username',
 3448    ]
 3449
 3450    def __init__(
 3451        self,
 3452        bind_interface=None,
 3453        database=None,
 3454        egress_filter=None,
 3455        healthy=None,
 3456        hostname=None,
 3457        id=None,
 3458        name=None,
 3459        password=None,
 3460        port=None,
 3461        port_override=None,
 3462        secret_store_id=None,
 3463        tags=None,
 3464        username=None,
 3465    ):
 3466        self.bind_interface = bind_interface if bind_interface is not None else ''
 3467        '''
 3468         Bind interface
 3469        '''
 3470        self.database = database if database is not None else ''
 3471        self.egress_filter = egress_filter if egress_filter is not None else ''
 3472        '''
 3473         A filter applied to the routing logic to pin datasource to nodes.
 3474        '''
 3475        self.healthy = healthy if healthy is not None else False
 3476        '''
 3477         True if the datasource is reachable and the credentials are valid.
 3478        '''
 3479        self.hostname = hostname if hostname is not None else ''
 3480        self.id = id if id is not None else ''
 3481        '''
 3482         Unique identifier of the Resource.
 3483        '''
 3484        self.name = name if name is not None else ''
 3485        '''
 3486         Unique human-readable name of the Resource.
 3487        '''
 3488        self.password = password if password is not None else ''
 3489        self.port = port if port is not None else 0
 3490        self.port_override = port_override if port_override is not None else 0
 3491        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3492        '''
 3493         ID of the secret store containing credentials for this resource, if any.
 3494        '''
 3495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3496        '''
 3497         Tags is a map of key, value pairs.
 3498        '''
 3499        self.username = username if username is not None else ''
 3500
 3501    def __repr__(self):
 3502        return '<sdm.Clustrix ' + \
 3503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3504            'database: ' + repr(self.database) + ' ' +\
 3505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3506            'healthy: ' + repr(self.healthy) + ' ' +\
 3507            'hostname: ' + repr(self.hostname) + ' ' +\
 3508            'id: ' + repr(self.id) + ' ' +\
 3509            'name: ' + repr(self.name) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'bind_interface': self.bind_interface,
 3521            'database': self.database,
 3522            'egress_filter': self.egress_filter,
 3523            'healthy': self.healthy,
 3524            'hostname': self.hostname,
 3525            'id': self.id,
 3526            'name': self.name,
 3527            'password': self.password,
 3528            'port': self.port,
 3529            'port_override': self.port_override,
 3530            'secret_store_id': self.secret_store_id,
 3531            'tags': self.tags,
 3532            'username': self.username,
 3533        }
 3534
 3535    @classmethod
 3536    def from_dict(cls, d):
 3537        return cls(
 3538            bind_interface=d.get('bind_interface'),
 3539            database=d.get('database'),
 3540            egress_filter=d.get('egress_filter'),
 3541            healthy=d.get('healthy'),
 3542            hostname=d.get('hostname'),
 3543            id=d.get('id'),
 3544            name=d.get('name'),
 3545            password=d.get('password'),
 3546            port=d.get('port'),
 3547            port_override=d.get('port_override'),
 3548            secret_store_id=d.get('secret_store_id'),
 3549            tags=d.get('tags'),
 3550            username=d.get('username'),
 3551        )
 3552
 3553
 3554class Cockroach:
 3555    __slots__ = [
 3556        'bind_interface',
 3557        'database',
 3558        'egress_filter',
 3559        'healthy',
 3560        'hostname',
 3561        'id',
 3562        'name',
 3563        'override_database',
 3564        'password',
 3565        'port',
 3566        'port_override',
 3567        'secret_store_id',
 3568        'tags',
 3569        'username',
 3570    ]
 3571
 3572    def __init__(
 3573        self,
 3574        bind_interface=None,
 3575        database=None,
 3576        egress_filter=None,
 3577        healthy=None,
 3578        hostname=None,
 3579        id=None,
 3580        name=None,
 3581        override_database=None,
 3582        password=None,
 3583        port=None,
 3584        port_override=None,
 3585        secret_store_id=None,
 3586        tags=None,
 3587        username=None,
 3588    ):
 3589        self.bind_interface = bind_interface if bind_interface is not None else ''
 3590        '''
 3591         Bind interface
 3592        '''
 3593        self.database = database if database is not None else ''
 3594        self.egress_filter = egress_filter if egress_filter is not None else ''
 3595        '''
 3596         A filter applied to the routing logic to pin datasource to nodes.
 3597        '''
 3598        self.healthy = healthy if healthy is not None else False
 3599        '''
 3600         True if the datasource is reachable and the credentials are valid.
 3601        '''
 3602        self.hostname = hostname if hostname is not None else ''
 3603        self.id = id if id is not None else ''
 3604        '''
 3605         Unique identifier of the Resource.
 3606        '''
 3607        self.name = name if name is not None else ''
 3608        '''
 3609         Unique human-readable name of the Resource.
 3610        '''
 3611        self.override_database = override_database if override_database is not None else False
 3612        self.password = password if password is not None else ''
 3613        self.port = port if port is not None else 0
 3614        self.port_override = port_override if port_override is not None else 0
 3615        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3616        '''
 3617         ID of the secret store containing credentials for this resource, if any.
 3618        '''
 3619        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3620        '''
 3621         Tags is a map of key, value pairs.
 3622        '''
 3623        self.username = username if username is not None else ''
 3624
 3625    def __repr__(self):
 3626        return '<sdm.Cockroach ' + \
 3627            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3628            'database: ' + repr(self.database) + ' ' +\
 3629            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3630            'healthy: ' + repr(self.healthy) + ' ' +\
 3631            'hostname: ' + repr(self.hostname) + ' ' +\
 3632            'id: ' + repr(self.id) + ' ' +\
 3633            'name: ' + repr(self.name) + ' ' +\
 3634            'override_database: ' + repr(self.override_database) + ' ' +\
 3635            'password: ' + repr(self.password) + ' ' +\
 3636            'port: ' + repr(self.port) + ' ' +\
 3637            'port_override: ' + repr(self.port_override) + ' ' +\
 3638            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3639            'tags: ' + repr(self.tags) + ' ' +\
 3640            'username: ' + repr(self.username) + ' ' +\
 3641            '>'
 3642
 3643    def to_dict(self):
 3644        return {
 3645            'bind_interface': self.bind_interface,
 3646            'database': self.database,
 3647            'egress_filter': self.egress_filter,
 3648            'healthy': self.healthy,
 3649            'hostname': self.hostname,
 3650            'id': self.id,
 3651            'name': self.name,
 3652            'override_database': self.override_database,
 3653            'password': self.password,
 3654            'port': self.port,
 3655            'port_override': self.port_override,
 3656            'secret_store_id': self.secret_store_id,
 3657            'tags': self.tags,
 3658            'username': self.username,
 3659        }
 3660
 3661    @classmethod
 3662    def from_dict(cls, d):
 3663        return cls(
 3664            bind_interface=d.get('bind_interface'),
 3665            database=d.get('database'),
 3666            egress_filter=d.get('egress_filter'),
 3667            healthy=d.get('healthy'),
 3668            hostname=d.get('hostname'),
 3669            id=d.get('id'),
 3670            name=d.get('name'),
 3671            override_database=d.get('override_database'),
 3672            password=d.get('password'),
 3673            port=d.get('port'),
 3674            port_override=d.get('port_override'),
 3675            secret_store_id=d.get('secret_store_id'),
 3676            tags=d.get('tags'),
 3677            username=d.get('username'),
 3678        )
 3679
 3680
 3681class ControlPanelGetSSHCAPublicKeyResponse:
 3682    '''
 3683         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3684     organization's SSH Certificate Authority public key.
 3685    '''
 3686    __slots__ = [
 3687        'meta',
 3688        'public_key',
 3689        'rate_limit',
 3690    ]
 3691
 3692    def __init__(
 3693        self,
 3694        meta=None,
 3695        public_key=None,
 3696        rate_limit=None,
 3697    ):
 3698        self.meta = meta if meta is not None else None
 3699        '''
 3700         Reserved for future use.
 3701        '''
 3702        self.public_key = public_key if public_key is not None else ''
 3703        '''
 3704         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3705         key format.
 3706        '''
 3707        self.rate_limit = rate_limit if rate_limit is not None else None
 3708        '''
 3709         Rate limit information.
 3710        '''
 3711
 3712    def __repr__(self):
 3713        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3714            'meta: ' + repr(self.meta) + ' ' +\
 3715            'public_key: ' + repr(self.public_key) + ' ' +\
 3716            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3717            '>'
 3718
 3719    def to_dict(self):
 3720        return {
 3721            'meta': self.meta,
 3722            'public_key': self.public_key,
 3723            'rate_limit': self.rate_limit,
 3724        }
 3725
 3726    @classmethod
 3727    def from_dict(cls, d):
 3728        return cls(
 3729            meta=d.get('meta'),
 3730            public_key=d.get('public_key'),
 3731            rate_limit=d.get('rate_limit'),
 3732        )
 3733
 3734
 3735class ControlPanelVerifyJWTResponse:
 3736    '''
 3737         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3738    '''
 3739    __slots__ = [
 3740        'meta',
 3741        'rate_limit',
 3742        'valid',
 3743    ]
 3744
 3745    def __init__(
 3746        self,
 3747        meta=None,
 3748        rate_limit=None,
 3749        valid=None,
 3750    ):
 3751        self.meta = meta if meta is not None else None
 3752        '''
 3753         Reserved for future use.
 3754        '''
 3755        self.rate_limit = rate_limit if rate_limit is not None else None
 3756        '''
 3757         Rate limit information.
 3758        '''
 3759        self.valid = valid if valid is not None else False
 3760        '''
 3761         Reports if the given token is valid.
 3762        '''
 3763
 3764    def __repr__(self):
 3765        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3766            'meta: ' + repr(self.meta) + ' ' +\
 3767            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3768            'valid: ' + repr(self.valid) + ' ' +\
 3769            '>'
 3770
 3771    def to_dict(self):
 3772        return {
 3773            'meta': self.meta,
 3774            'rate_limit': self.rate_limit,
 3775            'valid': self.valid,
 3776        }
 3777
 3778    @classmethod
 3779    def from_dict(cls, d):
 3780        return cls(
 3781            meta=d.get('meta'),
 3782            rate_limit=d.get('rate_limit'),
 3783            valid=d.get('valid'),
 3784        )
 3785
 3786
 3787class CreateResponseMetadata:
 3788    '''
 3789         CreateResponseMetadata is reserved for future use.
 3790    '''
 3791    __slots__ = []
 3792
 3793    def __init__(self, ):
 3794        pass
 3795
 3796    def __repr__(self):
 3797        return '<sdm.CreateResponseMetadata ' + \
 3798            '>'
 3799
 3800    def to_dict(self):
 3801        return {}
 3802
 3803    @classmethod
 3804    def from_dict(cls, d):
 3805        return cls()
 3806
 3807
 3808class CyberarkConjurStore:
 3809    '''
 3810    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
 3811    without a major version bump.
 3812    '''
 3813    __slots__ = [
 3814        'appurl',
 3815        'id',
 3816        'name',
 3817        'tags',
 3818    ]
 3819
 3820    def __init__(
 3821        self,
 3822        appurl=None,
 3823        id=None,
 3824        name=None,
 3825        tags=None,
 3826    ):
 3827        self.appurl = appurl if appurl is not None else ''
 3828        self.id = id if id is not None else ''
 3829        '''
 3830         Unique identifier of the SecretStore.
 3831        '''
 3832        self.name = name if name is not None else ''
 3833        '''
 3834         Unique human-readable name of the SecretStore.
 3835        '''
 3836        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3837        '''
 3838         Tags is a map of key, value pairs.
 3839        '''
 3840
 3841    def __repr__(self):
 3842        return '<sdm.CyberarkConjurStore ' + \
 3843            'appurl: ' + repr(self.appurl) + ' ' +\
 3844            'id: ' + repr(self.id) + ' ' +\
 3845            'name: ' + repr(self.name) + ' ' +\
 3846            'tags: ' + repr(self.tags) + ' ' +\
 3847            '>'
 3848
 3849    def to_dict(self):
 3850        return {
 3851            'appurl': self.appurl,
 3852            'id': self.id,
 3853            'name': self.name,
 3854            'tags': self.tags,
 3855        }
 3856
 3857    @classmethod
 3858    def from_dict(cls, d):
 3859        return cls(
 3860            appurl=d.get('appurl'),
 3861            id=d.get('id'),
 3862            name=d.get('name'),
 3863            tags=d.get('tags'),
 3864        )
 3865
 3866
 3867class CyberarkPAMExperimentalStore:
 3868    '''
 3869    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
 3870    without a major version bump.
 3871    '''
 3872    __slots__ = [
 3873        'appurl',
 3874        'id',
 3875        'name',
 3876        'tags',
 3877    ]
 3878
 3879    def __init__(
 3880        self,
 3881        appurl=None,
 3882        id=None,
 3883        name=None,
 3884        tags=None,
 3885    ):
 3886        self.appurl = appurl if appurl is not None else ''
 3887        self.id = id if id is not None else ''
 3888        '''
 3889         Unique identifier of the SecretStore.
 3890        '''
 3891        self.name = name if name is not None else ''
 3892        '''
 3893         Unique human-readable name of the SecretStore.
 3894        '''
 3895        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3896        '''
 3897         Tags is a map of key, value pairs.
 3898        '''
 3899
 3900    def __repr__(self):
 3901        return '<sdm.CyberarkPAMExperimentalStore ' + \
 3902            'appurl: ' + repr(self.appurl) + ' ' +\
 3903            'id: ' + repr(self.id) + ' ' +\
 3904            'name: ' + repr(self.name) + ' ' +\
 3905            'tags: ' + repr(self.tags) + ' ' +\
 3906            '>'
 3907
 3908    def to_dict(self):
 3909        return {
 3910            'appurl': self.appurl,
 3911            'id': self.id,
 3912            'name': self.name,
 3913            'tags': self.tags,
 3914        }
 3915
 3916    @classmethod
 3917    def from_dict(cls, d):
 3918        return cls(
 3919            appurl=d.get('appurl'),
 3920            id=d.get('id'),
 3921            name=d.get('name'),
 3922            tags=d.get('tags'),
 3923        )
 3924
 3925
 3926class DB2I:
 3927    __slots__ = [
 3928        'bind_interface',
 3929        'egress_filter',
 3930        'healthy',
 3931        'hostname',
 3932        'id',
 3933        'name',
 3934        'password',
 3935        'port',
 3936        'port_override',
 3937        'secret_store_id',
 3938        'tags',
 3939        'tls_required',
 3940        'username',
 3941    ]
 3942
 3943    def __init__(
 3944        self,
 3945        bind_interface=None,
 3946        egress_filter=None,
 3947        healthy=None,
 3948        hostname=None,
 3949        id=None,
 3950        name=None,
 3951        password=None,
 3952        port=None,
 3953        port_override=None,
 3954        secret_store_id=None,
 3955        tags=None,
 3956        tls_required=None,
 3957        username=None,
 3958    ):
 3959        self.bind_interface = bind_interface if bind_interface is not None else ''
 3960        '''
 3961         Bind interface
 3962        '''
 3963        self.egress_filter = egress_filter if egress_filter is not None else ''
 3964        '''
 3965         A filter applied to the routing logic to pin datasource to nodes.
 3966        '''
 3967        self.healthy = healthy if healthy is not None else False
 3968        '''
 3969         True if the datasource is reachable and the credentials are valid.
 3970        '''
 3971        self.hostname = hostname if hostname is not None else ''
 3972        self.id = id if id is not None else ''
 3973        '''
 3974         Unique identifier of the Resource.
 3975        '''
 3976        self.name = name if name is not None else ''
 3977        '''
 3978         Unique human-readable name of the Resource.
 3979        '''
 3980        self.password = password if password is not None else ''
 3981        self.port = port if port is not None else 0
 3982        self.port_override = port_override if port_override is not None else 0
 3983        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3984        '''
 3985         ID of the secret store containing credentials for this resource, if any.
 3986        '''
 3987        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3988        '''
 3989         Tags is a map of key, value pairs.
 3990        '''
 3991        self.tls_required = tls_required if tls_required is not None else False
 3992        self.username = username if username is not None else ''
 3993
 3994    def __repr__(self):
 3995        return '<sdm.DB2I ' + \
 3996            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3997            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3998            'healthy: ' + repr(self.healthy) + ' ' +\
 3999            'hostname: ' + repr(self.hostname) + ' ' +\
 4000            'id: ' + repr(self.id) + ' ' +\
 4001            'name: ' + repr(self.name) + ' ' +\
 4002            'password: ' + repr(self.password) + ' ' +\
 4003            'port: ' + repr(self.port) + ' ' +\
 4004            'port_override: ' + repr(self.port_override) + ' ' +\
 4005            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4006            'tags: ' + repr(self.tags) + ' ' +\
 4007            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4008            'username: ' + repr(self.username) + ' ' +\
 4009            '>'
 4010
 4011    def to_dict(self):
 4012        return {
 4013            'bind_interface': self.bind_interface,
 4014            'egress_filter': self.egress_filter,
 4015            'healthy': self.healthy,
 4016            'hostname': self.hostname,
 4017            'id': self.id,
 4018            'name': self.name,
 4019            'password': self.password,
 4020            'port': self.port,
 4021            'port_override': self.port_override,
 4022            'secret_store_id': self.secret_store_id,
 4023            'tags': self.tags,
 4024            'tls_required': self.tls_required,
 4025            'username': self.username,
 4026        }
 4027
 4028    @classmethod
 4029    def from_dict(cls, d):
 4030        return cls(
 4031            bind_interface=d.get('bind_interface'),
 4032            egress_filter=d.get('egress_filter'),
 4033            healthy=d.get('healthy'),
 4034            hostname=d.get('hostname'),
 4035            id=d.get('id'),
 4036            name=d.get('name'),
 4037            password=d.get('password'),
 4038            port=d.get('port'),
 4039            port_override=d.get('port_override'),
 4040            secret_store_id=d.get('secret_store_id'),
 4041            tags=d.get('tags'),
 4042            tls_required=d.get('tls_required'),
 4043            username=d.get('username'),
 4044        )
 4045
 4046
 4047class DB2LUW:
 4048    __slots__ = [
 4049        'bind_interface',
 4050        'database',
 4051        'egress_filter',
 4052        'healthy',
 4053        'hostname',
 4054        'id',
 4055        'name',
 4056        'password',
 4057        'port',
 4058        'port_override',
 4059        'secret_store_id',
 4060        'tags',
 4061        'username',
 4062    ]
 4063
 4064    def __init__(
 4065        self,
 4066        bind_interface=None,
 4067        database=None,
 4068        egress_filter=None,
 4069        healthy=None,
 4070        hostname=None,
 4071        id=None,
 4072        name=None,
 4073        password=None,
 4074        port=None,
 4075        port_override=None,
 4076        secret_store_id=None,
 4077        tags=None,
 4078        username=None,
 4079    ):
 4080        self.bind_interface = bind_interface if bind_interface is not None else ''
 4081        '''
 4082         Bind interface
 4083        '''
 4084        self.database = database if database is not None else ''
 4085        self.egress_filter = egress_filter if egress_filter is not None else ''
 4086        '''
 4087         A filter applied to the routing logic to pin datasource to nodes.
 4088        '''
 4089        self.healthy = healthy if healthy is not None else False
 4090        '''
 4091         True if the datasource is reachable and the credentials are valid.
 4092        '''
 4093        self.hostname = hostname if hostname is not None else ''
 4094        self.id = id if id is not None else ''
 4095        '''
 4096         Unique identifier of the Resource.
 4097        '''
 4098        self.name = name if name is not None else ''
 4099        '''
 4100         Unique human-readable name of the Resource.
 4101        '''
 4102        self.password = password if password is not None else ''
 4103        self.port = port if port is not None else 0
 4104        self.port_override = port_override if port_override is not None else 0
 4105        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4106        '''
 4107         ID of the secret store containing credentials for this resource, if any.
 4108        '''
 4109        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4110        '''
 4111         Tags is a map of key, value pairs.
 4112        '''
 4113        self.username = username if username is not None else ''
 4114
 4115    def __repr__(self):
 4116        return '<sdm.DB2LUW ' + \
 4117            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4118            'database: ' + repr(self.database) + ' ' +\
 4119            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4120            'healthy: ' + repr(self.healthy) + ' ' +\
 4121            'hostname: ' + repr(self.hostname) + ' ' +\
 4122            'id: ' + repr(self.id) + ' ' +\
 4123            'name: ' + repr(self.name) + ' ' +\
 4124            'password: ' + repr(self.password) + ' ' +\
 4125            'port: ' + repr(self.port) + ' ' +\
 4126            'port_override: ' + repr(self.port_override) + ' ' +\
 4127            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4128            'tags: ' + repr(self.tags) + ' ' +\
 4129            'username: ' + repr(self.username) + ' ' +\
 4130            '>'
 4131
 4132    def to_dict(self):
 4133        return {
 4134            'bind_interface': self.bind_interface,
 4135            'database': self.database,
 4136            'egress_filter': self.egress_filter,
 4137            'healthy': self.healthy,
 4138            'hostname': self.hostname,
 4139            'id': self.id,
 4140            'name': self.name,
 4141            'password': self.password,
 4142            'port': self.port,
 4143            'port_override': self.port_override,
 4144            'secret_store_id': self.secret_store_id,
 4145            'tags': self.tags,
 4146            'username': self.username,
 4147        }
 4148
 4149    @classmethod
 4150    def from_dict(cls, d):
 4151        return cls(
 4152            bind_interface=d.get('bind_interface'),
 4153            database=d.get('database'),
 4154            egress_filter=d.get('egress_filter'),
 4155            healthy=d.get('healthy'),
 4156            hostname=d.get('hostname'),
 4157            id=d.get('id'),
 4158            name=d.get('name'),
 4159            password=d.get('password'),
 4160            port=d.get('port'),
 4161            port_override=d.get('port_override'),
 4162            secret_store_id=d.get('secret_store_id'),
 4163            tags=d.get('tags'),
 4164            username=d.get('username'),
 4165        )
 4166
 4167
 4168class DeleteResponseMetadata:
 4169    '''
 4170         DeleteResponseMetadata is reserved for future use.
 4171    '''
 4172    __slots__ = []
 4173
 4174    def __init__(self, ):
 4175        pass
 4176
 4177    def __repr__(self):
 4178        return '<sdm.DeleteResponseMetadata ' + \
 4179            '>'
 4180
 4181    def to_dict(self):
 4182        return {}
 4183
 4184    @classmethod
 4185    def from_dict(cls, d):
 4186        return cls()
 4187
 4188
 4189class DelineaStore:
 4190    '''
 4191    DelineaStore is currently unstable, and its API may change, or it may be removed,
 4192    without a major version bump.
 4193    '''
 4194    __slots__ = [
 4195        'id',
 4196        'name',
 4197        'server_url',
 4198        'tags',
 4199        'tenant_name',
 4200    ]
 4201
 4202    def __init__(
 4203        self,
 4204        id=None,
 4205        name=None,
 4206        server_url=None,
 4207        tags=None,
 4208        tenant_name=None,
 4209    ):
 4210        self.id = id if id is not None else ''
 4211        '''
 4212         Unique identifier of the SecretStore.
 4213        '''
 4214        self.name = name if name is not None else ''
 4215        '''
 4216         Unique human-readable name of the SecretStore.
 4217        '''
 4218        self.server_url = server_url if server_url is not None else ''
 4219        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4220        '''
 4221         Tags is a map of key, value pairs.
 4222        '''
 4223        self.tenant_name = tenant_name if tenant_name is not None else ''
 4224
 4225    def __repr__(self):
 4226        return '<sdm.DelineaStore ' + \
 4227            'id: ' + repr(self.id) + ' ' +\
 4228            'name: ' + repr(self.name) + ' ' +\
 4229            'server_url: ' + repr(self.server_url) + ' ' +\
 4230            'tags: ' + repr(self.tags) + ' ' +\
 4231            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 4232            '>'
 4233
 4234    def to_dict(self):
 4235        return {
 4236            'id': self.id,
 4237            'name': self.name,
 4238            'server_url': self.server_url,
 4239            'tags': self.tags,
 4240            'tenant_name': self.tenant_name,
 4241        }
 4242
 4243    @classmethod
 4244    def from_dict(cls, d):
 4245        return cls(
 4246            id=d.get('id'),
 4247            name=d.get('name'),
 4248            server_url=d.get('server_url'),
 4249            tags=d.get('tags'),
 4250            tenant_name=d.get('tenant_name'),
 4251        )
 4252
 4253
 4254class DocumentDBHost:
 4255    __slots__ = [
 4256        'auth_database',
 4257        'bind_interface',
 4258        'egress_filter',
 4259        'healthy',
 4260        'hostname',
 4261        'id',
 4262        'name',
 4263        'password',
 4264        'port',
 4265        'port_override',
 4266        'secret_store_id',
 4267        'tags',
 4268        'username',
 4269    ]
 4270
 4271    def __init__(
 4272        self,
 4273        auth_database=None,
 4274        bind_interface=None,
 4275        egress_filter=None,
 4276        healthy=None,
 4277        hostname=None,
 4278        id=None,
 4279        name=None,
 4280        password=None,
 4281        port=None,
 4282        port_override=None,
 4283        secret_store_id=None,
 4284        tags=None,
 4285        username=None,
 4286    ):
 4287        self.auth_database = auth_database if auth_database is not None else ''
 4288        self.bind_interface = bind_interface if bind_interface is not None else ''
 4289        '''
 4290         Bind interface
 4291        '''
 4292        self.egress_filter = egress_filter if egress_filter is not None else ''
 4293        '''
 4294         A filter applied to the routing logic to pin datasource to nodes.
 4295        '''
 4296        self.healthy = healthy if healthy is not None else False
 4297        '''
 4298         True if the datasource is reachable and the credentials are valid.
 4299        '''
 4300        self.hostname = hostname if hostname is not None else ''
 4301        self.id = id if id is not None else ''
 4302        '''
 4303         Unique identifier of the Resource.
 4304        '''
 4305        self.name = name if name is not None else ''
 4306        '''
 4307         Unique human-readable name of the Resource.
 4308        '''
 4309        self.password = password if password is not None else ''
 4310        self.port = port if port is not None else 0
 4311        self.port_override = port_override if port_override is not None else 0
 4312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4313        '''
 4314         ID of the secret store containing credentials for this resource, if any.
 4315        '''
 4316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4317        '''
 4318         Tags is a map of key, value pairs.
 4319        '''
 4320        self.username = username if username is not None else ''
 4321
 4322    def __repr__(self):
 4323        return '<sdm.DocumentDBHost ' + \
 4324            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4325            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4326            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4327            'healthy: ' + repr(self.healthy) + ' ' +\
 4328            'hostname: ' + repr(self.hostname) + ' ' +\
 4329            'id: ' + repr(self.id) + ' ' +\
 4330            'name: ' + repr(self.name) + ' ' +\
 4331            'password: ' + repr(self.password) + ' ' +\
 4332            'port: ' + repr(self.port) + ' ' +\
 4333            'port_override: ' + repr(self.port_override) + ' ' +\
 4334            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4335            'tags: ' + repr(self.tags) + ' ' +\
 4336            'username: ' + repr(self.username) + ' ' +\
 4337            '>'
 4338
 4339    def to_dict(self):
 4340        return {
 4341            'auth_database': self.auth_database,
 4342            'bind_interface': self.bind_interface,
 4343            'egress_filter': self.egress_filter,
 4344            'healthy': self.healthy,
 4345            'hostname': self.hostname,
 4346            'id': self.id,
 4347            'name': self.name,
 4348            'password': self.password,
 4349            'port': self.port,
 4350            'port_override': self.port_override,
 4351            'secret_store_id': self.secret_store_id,
 4352            'tags': self.tags,
 4353            'username': self.username,
 4354        }
 4355
 4356    @classmethod
 4357    def from_dict(cls, d):
 4358        return cls(
 4359            auth_database=d.get('auth_database'),
 4360            bind_interface=d.get('bind_interface'),
 4361            egress_filter=d.get('egress_filter'),
 4362            healthy=d.get('healthy'),
 4363            hostname=d.get('hostname'),
 4364            id=d.get('id'),
 4365            name=d.get('name'),
 4366            password=d.get('password'),
 4367            port=d.get('port'),
 4368            port_override=d.get('port_override'),
 4369            secret_store_id=d.get('secret_store_id'),
 4370            tags=d.get('tags'),
 4371            username=d.get('username'),
 4372        )
 4373
 4374
 4375class DocumentDBReplicaSet:
 4376    __slots__ = [
 4377        'auth_database',
 4378        'bind_interface',
 4379        'connect_to_replica',
 4380        'egress_filter',
 4381        'healthy',
 4382        'hostname',
 4383        'id',
 4384        'name',
 4385        'password',
 4386        'port_override',
 4387        'replica_set',
 4388        'secret_store_id',
 4389        'tags',
 4390        'username',
 4391    ]
 4392
 4393    def __init__(
 4394        self,
 4395        auth_database=None,
 4396        bind_interface=None,
 4397        connect_to_replica=None,
 4398        egress_filter=None,
 4399        healthy=None,
 4400        hostname=None,
 4401        id=None,
 4402        name=None,
 4403        password=None,
 4404        port_override=None,
 4405        replica_set=None,
 4406        secret_store_id=None,
 4407        tags=None,
 4408        username=None,
 4409    ):
 4410        self.auth_database = auth_database if auth_database is not None else ''
 4411        self.bind_interface = bind_interface if bind_interface is not None else ''
 4412        '''
 4413         Bind interface
 4414        '''
 4415        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4416        self.egress_filter = egress_filter if egress_filter is not None else ''
 4417        '''
 4418         A filter applied to the routing logic to pin datasource to nodes.
 4419        '''
 4420        self.healthy = healthy if healthy is not None else False
 4421        '''
 4422         True if the datasource is reachable and the credentials are valid.
 4423        '''
 4424        self.hostname = hostname if hostname is not None else ''
 4425        '''
 4426         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4427        '''
 4428        self.id = id if id is not None else ''
 4429        '''
 4430         Unique identifier of the Resource.
 4431        '''
 4432        self.name = name if name is not None else ''
 4433        '''
 4434         Unique human-readable name of the Resource.
 4435        '''
 4436        self.password = password if password is not None else ''
 4437        self.port_override = port_override if port_override is not None else 0
 4438        self.replica_set = replica_set if replica_set is not None else ''
 4439        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4440        '''
 4441         ID of the secret store containing credentials for this resource, if any.
 4442        '''
 4443        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4444        '''
 4445         Tags is a map of key, value pairs.
 4446        '''
 4447        self.username = username if username is not None else ''
 4448
 4449    def __repr__(self):
 4450        return '<sdm.DocumentDBReplicaSet ' + \
 4451            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4452            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4453            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4454            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4455            'healthy: ' + repr(self.healthy) + ' ' +\
 4456            'hostname: ' + repr(self.hostname) + ' ' +\
 4457            'id: ' + repr(self.id) + ' ' +\
 4458            'name: ' + repr(self.name) + ' ' +\
 4459            'password: ' + repr(self.password) + ' ' +\
 4460            'port_override: ' + repr(self.port_override) + ' ' +\
 4461            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4462            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4463            'tags: ' + repr(self.tags) + ' ' +\
 4464            'username: ' + repr(self.username) + ' ' +\
 4465            '>'
 4466
 4467    def to_dict(self):
 4468        return {
 4469            'auth_database': self.auth_database,
 4470            'bind_interface': self.bind_interface,
 4471            'connect_to_replica': self.connect_to_replica,
 4472            'egress_filter': self.egress_filter,
 4473            'healthy': self.healthy,
 4474            'hostname': self.hostname,
 4475            'id': self.id,
 4476            'name': self.name,
 4477            'password': self.password,
 4478            'port_override': self.port_override,
 4479            'replica_set': self.replica_set,
 4480            'secret_store_id': self.secret_store_id,
 4481            'tags': self.tags,
 4482            'username': self.username,
 4483        }
 4484
 4485    @classmethod
 4486    def from_dict(cls, d):
 4487        return cls(
 4488            auth_database=d.get('auth_database'),
 4489            bind_interface=d.get('bind_interface'),
 4490            connect_to_replica=d.get('connect_to_replica'),
 4491            egress_filter=d.get('egress_filter'),
 4492            healthy=d.get('healthy'),
 4493            hostname=d.get('hostname'),
 4494            id=d.get('id'),
 4495            name=d.get('name'),
 4496            password=d.get('password'),
 4497            port_override=d.get('port_override'),
 4498            replica_set=d.get('replica_set'),
 4499            secret_store_id=d.get('secret_store_id'),
 4500            tags=d.get('tags'),
 4501            username=d.get('username'),
 4502        )
 4503
 4504
 4505class Druid:
 4506    __slots__ = [
 4507        'bind_interface',
 4508        'egress_filter',
 4509        'healthy',
 4510        'hostname',
 4511        'id',
 4512        'name',
 4513        'password',
 4514        'port',
 4515        'port_override',
 4516        'secret_store_id',
 4517        'tags',
 4518        'username',
 4519    ]
 4520
 4521    def __init__(
 4522        self,
 4523        bind_interface=None,
 4524        egress_filter=None,
 4525        healthy=None,
 4526        hostname=None,
 4527        id=None,
 4528        name=None,
 4529        password=None,
 4530        port=None,
 4531        port_override=None,
 4532        secret_store_id=None,
 4533        tags=None,
 4534        username=None,
 4535    ):
 4536        self.bind_interface = bind_interface if bind_interface is not None else ''
 4537        '''
 4538         Bind interface
 4539        '''
 4540        self.egress_filter = egress_filter if egress_filter is not None else ''
 4541        '''
 4542         A filter applied to the routing logic to pin datasource to nodes.
 4543        '''
 4544        self.healthy = healthy if healthy is not None else False
 4545        '''
 4546         True if the datasource is reachable and the credentials are valid.
 4547        '''
 4548        self.hostname = hostname if hostname is not None else ''
 4549        self.id = id if id is not None else ''
 4550        '''
 4551         Unique identifier of the Resource.
 4552        '''
 4553        self.name = name if name is not None else ''
 4554        '''
 4555         Unique human-readable name of the Resource.
 4556        '''
 4557        self.password = password if password is not None else ''
 4558        self.port = port if port is not None else 0
 4559        self.port_override = port_override if port_override is not None else 0
 4560        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4561        '''
 4562         ID of the secret store containing credentials for this resource, if any.
 4563        '''
 4564        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4565        '''
 4566         Tags is a map of key, value pairs.
 4567        '''
 4568        self.username = username if username is not None else ''
 4569
 4570    def __repr__(self):
 4571        return '<sdm.Druid ' + \
 4572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4573            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4574            'healthy: ' + repr(self.healthy) + ' ' +\
 4575            'hostname: ' + repr(self.hostname) + ' ' +\
 4576            'id: ' + repr(self.id) + ' ' +\
 4577            'name: ' + repr(self.name) + ' ' +\
 4578            'password: ' + repr(self.password) + ' ' +\
 4579            'port: ' + repr(self.port) + ' ' +\
 4580            'port_override: ' + repr(self.port_override) + ' ' +\
 4581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4582            'tags: ' + repr(self.tags) + ' ' +\
 4583            'username: ' + repr(self.username) + ' ' +\
 4584            '>'
 4585
 4586    def to_dict(self):
 4587        return {
 4588            'bind_interface': self.bind_interface,
 4589            'egress_filter': self.egress_filter,
 4590            'healthy': self.healthy,
 4591            'hostname': self.hostname,
 4592            'id': self.id,
 4593            'name': self.name,
 4594            'password': self.password,
 4595            'port': self.port,
 4596            'port_override': self.port_override,
 4597            'secret_store_id': self.secret_store_id,
 4598            'tags': self.tags,
 4599            'username': self.username,
 4600        }
 4601
 4602    @classmethod
 4603    def from_dict(cls, d):
 4604        return cls(
 4605            bind_interface=d.get('bind_interface'),
 4606            egress_filter=d.get('egress_filter'),
 4607            healthy=d.get('healthy'),
 4608            hostname=d.get('hostname'),
 4609            id=d.get('id'),
 4610            name=d.get('name'),
 4611            password=d.get('password'),
 4612            port=d.get('port'),
 4613            port_override=d.get('port_override'),
 4614            secret_store_id=d.get('secret_store_id'),
 4615            tags=d.get('tags'),
 4616            username=d.get('username'),
 4617        )
 4618
 4619
 4620class DynamoDB:
 4621    __slots__ = [
 4622        'access_key',
 4623        'bind_interface',
 4624        'egress_filter',
 4625        'endpoint',
 4626        'healthy',
 4627        'id',
 4628        'name',
 4629        'port_override',
 4630        'region',
 4631        'role_arn',
 4632        'role_external_id',
 4633        'secret_access_key',
 4634        'secret_store_id',
 4635        'tags',
 4636    ]
 4637
 4638    def __init__(
 4639        self,
 4640        access_key=None,
 4641        bind_interface=None,
 4642        egress_filter=None,
 4643        endpoint=None,
 4644        healthy=None,
 4645        id=None,
 4646        name=None,
 4647        port_override=None,
 4648        region=None,
 4649        role_arn=None,
 4650        role_external_id=None,
 4651        secret_access_key=None,
 4652        secret_store_id=None,
 4653        tags=None,
 4654    ):
 4655        self.access_key = access_key if access_key is not None else ''
 4656        self.bind_interface = bind_interface if bind_interface is not None else ''
 4657        '''
 4658         Bind interface
 4659        '''
 4660        self.egress_filter = egress_filter if egress_filter is not None else ''
 4661        '''
 4662         A filter applied to the routing logic to pin datasource to nodes.
 4663        '''
 4664        self.endpoint = endpoint if endpoint is not None else ''
 4665        self.healthy = healthy if healthy is not None else False
 4666        '''
 4667         True if the datasource is reachable and the credentials are valid.
 4668        '''
 4669        self.id = id if id is not None else ''
 4670        '''
 4671         Unique identifier of the Resource.
 4672        '''
 4673        self.name = name if name is not None else ''
 4674        '''
 4675         Unique human-readable name of the Resource.
 4676        '''
 4677        self.port_override = port_override if port_override is not None else 0
 4678        self.region = region if region is not None else ''
 4679        self.role_arn = role_arn if role_arn is not None else ''
 4680        self.role_external_id = role_external_id if role_external_id is not None else ''
 4681        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4682        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4683        '''
 4684         ID of the secret store containing credentials for this resource, if any.
 4685        '''
 4686        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4687        '''
 4688         Tags is a map of key, value pairs.
 4689        '''
 4690
 4691    def __repr__(self):
 4692        return '<sdm.DynamoDB ' + \
 4693            'access_key: ' + repr(self.access_key) + ' ' +\
 4694            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4695            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4696            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4697            'healthy: ' + repr(self.healthy) + ' ' +\
 4698            'id: ' + repr(self.id) + ' ' +\
 4699            'name: ' + repr(self.name) + ' ' +\
 4700            'port_override: ' + repr(self.port_override) + ' ' +\
 4701            'region: ' + repr(self.region) + ' ' +\
 4702            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4703            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4704            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4705            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4706            'tags: ' + repr(self.tags) + ' ' +\
 4707            '>'
 4708
 4709    def to_dict(self):
 4710        return {
 4711            'access_key': self.access_key,
 4712            'bind_interface': self.bind_interface,
 4713            'egress_filter': self.egress_filter,
 4714            'endpoint': self.endpoint,
 4715            'healthy': self.healthy,
 4716            'id': self.id,
 4717            'name': self.name,
 4718            'port_override': self.port_override,
 4719            'region': self.region,
 4720            'role_arn': self.role_arn,
 4721            'role_external_id': self.role_external_id,
 4722            'secret_access_key': self.secret_access_key,
 4723            'secret_store_id': self.secret_store_id,
 4724            'tags': self.tags,
 4725        }
 4726
 4727    @classmethod
 4728    def from_dict(cls, d):
 4729        return cls(
 4730            access_key=d.get('access_key'),
 4731            bind_interface=d.get('bind_interface'),
 4732            egress_filter=d.get('egress_filter'),
 4733            endpoint=d.get('endpoint'),
 4734            healthy=d.get('healthy'),
 4735            id=d.get('id'),
 4736            name=d.get('name'),
 4737            port_override=d.get('port_override'),
 4738            region=d.get('region'),
 4739            role_arn=d.get('role_arn'),
 4740            role_external_id=d.get('role_external_id'),
 4741            secret_access_key=d.get('secret_access_key'),
 4742            secret_store_id=d.get('secret_store_id'),
 4743            tags=d.get('tags'),
 4744        )
 4745
 4746
 4747class Elastic:
 4748    __slots__ = [
 4749        'bind_interface',
 4750        'egress_filter',
 4751        'healthy',
 4752        'hostname',
 4753        'id',
 4754        'name',
 4755        'password',
 4756        'port',
 4757        'port_override',
 4758        'secret_store_id',
 4759        'tags',
 4760        'tls_required',
 4761        'username',
 4762    ]
 4763
 4764    def __init__(
 4765        self,
 4766        bind_interface=None,
 4767        egress_filter=None,
 4768        healthy=None,
 4769        hostname=None,
 4770        id=None,
 4771        name=None,
 4772        password=None,
 4773        port=None,
 4774        port_override=None,
 4775        secret_store_id=None,
 4776        tags=None,
 4777        tls_required=None,
 4778        username=None,
 4779    ):
 4780        self.bind_interface = bind_interface if bind_interface is not None else ''
 4781        '''
 4782         Bind interface
 4783        '''
 4784        self.egress_filter = egress_filter if egress_filter is not None else ''
 4785        '''
 4786         A filter applied to the routing logic to pin datasource to nodes.
 4787        '''
 4788        self.healthy = healthy if healthy is not None else False
 4789        '''
 4790         True if the datasource is reachable and the credentials are valid.
 4791        '''
 4792        self.hostname = hostname if hostname is not None else ''
 4793        self.id = id if id is not None else ''
 4794        '''
 4795         Unique identifier of the Resource.
 4796        '''
 4797        self.name = name if name is not None else ''
 4798        '''
 4799         Unique human-readable name of the Resource.
 4800        '''
 4801        self.password = password if password is not None else ''
 4802        self.port = port if port is not None else 0
 4803        self.port_override = port_override if port_override is not None else 0
 4804        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4805        '''
 4806         ID of the secret store containing credentials for this resource, if any.
 4807        '''
 4808        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4809        '''
 4810         Tags is a map of key, value pairs.
 4811        '''
 4812        self.tls_required = tls_required if tls_required is not None else False
 4813        self.username = username if username is not None else ''
 4814
 4815    def __repr__(self):
 4816        return '<sdm.Elastic ' + \
 4817            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4818            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4819            'healthy: ' + repr(self.healthy) + ' ' +\
 4820            'hostname: ' + repr(self.hostname) + ' ' +\
 4821            'id: ' + repr(self.id) + ' ' +\
 4822            'name: ' + repr(self.name) + ' ' +\
 4823            'password: ' + repr(self.password) + ' ' +\
 4824            'port: ' + repr(self.port) + ' ' +\
 4825            'port_override: ' + repr(self.port_override) + ' ' +\
 4826            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4827            'tags: ' + repr(self.tags) + ' ' +\
 4828            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4829            'username: ' + repr(self.username) + ' ' +\
 4830            '>'
 4831
 4832    def to_dict(self):
 4833        return {
 4834            'bind_interface': self.bind_interface,
 4835            'egress_filter': self.egress_filter,
 4836            'healthy': self.healthy,
 4837            'hostname': self.hostname,
 4838            'id': self.id,
 4839            'name': self.name,
 4840            'password': self.password,
 4841            'port': self.port,
 4842            'port_override': self.port_override,
 4843            'secret_store_id': self.secret_store_id,
 4844            'tags': self.tags,
 4845            'tls_required': self.tls_required,
 4846            'username': self.username,
 4847        }
 4848
 4849    @classmethod
 4850    def from_dict(cls, d):
 4851        return cls(
 4852            bind_interface=d.get('bind_interface'),
 4853            egress_filter=d.get('egress_filter'),
 4854            healthy=d.get('healthy'),
 4855            hostname=d.get('hostname'),
 4856            id=d.get('id'),
 4857            name=d.get('name'),
 4858            password=d.get('password'),
 4859            port=d.get('port'),
 4860            port_override=d.get('port_override'),
 4861            secret_store_id=d.get('secret_store_id'),
 4862            tags=d.get('tags'),
 4863            tls_required=d.get('tls_required'),
 4864            username=d.get('username'),
 4865        )
 4866
 4867
 4868class ElasticacheRedis:
 4869    __slots__ = [
 4870        'bind_interface',
 4871        'egress_filter',
 4872        'healthy',
 4873        'hostname',
 4874        'id',
 4875        'name',
 4876        'password',
 4877        'port',
 4878        'port_override',
 4879        'secret_store_id',
 4880        'tags',
 4881        'tls_required',
 4882    ]
 4883
 4884    def __init__(
 4885        self,
 4886        bind_interface=None,
 4887        egress_filter=None,
 4888        healthy=None,
 4889        hostname=None,
 4890        id=None,
 4891        name=None,
 4892        password=None,
 4893        port=None,
 4894        port_override=None,
 4895        secret_store_id=None,
 4896        tags=None,
 4897        tls_required=None,
 4898    ):
 4899        self.bind_interface = bind_interface if bind_interface is not None else ''
 4900        '''
 4901         Bind interface
 4902        '''
 4903        self.egress_filter = egress_filter if egress_filter is not None else ''
 4904        '''
 4905         A filter applied to the routing logic to pin datasource to nodes.
 4906        '''
 4907        self.healthy = healthy if healthy is not None else False
 4908        '''
 4909         True if the datasource is reachable and the credentials are valid.
 4910        '''
 4911        self.hostname = hostname if hostname is not None else ''
 4912        self.id = id if id is not None else ''
 4913        '''
 4914         Unique identifier of the Resource.
 4915        '''
 4916        self.name = name if name is not None else ''
 4917        '''
 4918         Unique human-readable name of the Resource.
 4919        '''
 4920        self.password = password if password is not None else ''
 4921        self.port = port if port is not None else 0
 4922        self.port_override = port_override if port_override is not None else 0
 4923        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4924        '''
 4925         ID of the secret store containing credentials for this resource, if any.
 4926        '''
 4927        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4928        '''
 4929         Tags is a map of key, value pairs.
 4930        '''
 4931        self.tls_required = tls_required if tls_required is not None else False
 4932
 4933    def __repr__(self):
 4934        return '<sdm.ElasticacheRedis ' + \
 4935            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4936            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4937            'healthy: ' + repr(self.healthy) + ' ' +\
 4938            'hostname: ' + repr(self.hostname) + ' ' +\
 4939            'id: ' + repr(self.id) + ' ' +\
 4940            'name: ' + repr(self.name) + ' ' +\
 4941            'password: ' + repr(self.password) + ' ' +\
 4942            'port: ' + repr(self.port) + ' ' +\
 4943            'port_override: ' + repr(self.port_override) + ' ' +\
 4944            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4945            'tags: ' + repr(self.tags) + ' ' +\
 4946            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4947            '>'
 4948
 4949    def to_dict(self):
 4950        return {
 4951            'bind_interface': self.bind_interface,
 4952            'egress_filter': self.egress_filter,
 4953            'healthy': self.healthy,
 4954            'hostname': self.hostname,
 4955            'id': self.id,
 4956            'name': self.name,
 4957            'password': self.password,
 4958            'port': self.port,
 4959            'port_override': self.port_override,
 4960            'secret_store_id': self.secret_store_id,
 4961            'tags': self.tags,
 4962            'tls_required': self.tls_required,
 4963        }
 4964
 4965    @classmethod
 4966    def from_dict(cls, d):
 4967        return cls(
 4968            bind_interface=d.get('bind_interface'),
 4969            egress_filter=d.get('egress_filter'),
 4970            healthy=d.get('healthy'),
 4971            hostname=d.get('hostname'),
 4972            id=d.get('id'),
 4973            name=d.get('name'),
 4974            password=d.get('password'),
 4975            port=d.get('port'),
 4976            port_override=d.get('port_override'),
 4977            secret_store_id=d.get('secret_store_id'),
 4978            tags=d.get('tags'),
 4979            tls_required=d.get('tls_required'),
 4980        )
 4981
 4982
 4983class GCP:
 4984    __slots__ = [
 4985        'bind_interface',
 4986        'egress_filter',
 4987        'healthy',
 4988        'id',
 4989        'keyfile',
 4990        'name',
 4991        'scopes',
 4992        'secret_store_id',
 4993        'tags',
 4994    ]
 4995
 4996    def __init__(
 4997        self,
 4998        bind_interface=None,
 4999        egress_filter=None,
 5000        healthy=None,
 5001        id=None,
 5002        keyfile=None,
 5003        name=None,
 5004        scopes=None,
 5005        secret_store_id=None,
 5006        tags=None,
 5007    ):
 5008        self.bind_interface = bind_interface if bind_interface is not None else ''
 5009        '''
 5010         Bind interface
 5011        '''
 5012        self.egress_filter = egress_filter if egress_filter is not None else ''
 5013        '''
 5014         A filter applied to the routing logic to pin datasource to nodes.
 5015        '''
 5016        self.healthy = healthy if healthy is not None else False
 5017        '''
 5018         True if the datasource is reachable and the credentials are valid.
 5019        '''
 5020        self.id = id if id is not None else ''
 5021        '''
 5022         Unique identifier of the Resource.
 5023        '''
 5024        self.keyfile = keyfile if keyfile is not None else ''
 5025        self.name = name if name is not None else ''
 5026        '''
 5027         Unique human-readable name of the Resource.
 5028        '''
 5029        self.scopes = scopes if scopes is not None else ''
 5030        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5031        '''
 5032         ID of the secret store containing credentials for this resource, if any.
 5033        '''
 5034        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5035        '''
 5036         Tags is a map of key, value pairs.
 5037        '''
 5038
 5039    def __repr__(self):
 5040        return '<sdm.GCP ' + \
 5041            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5042            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5043            'healthy: ' + repr(self.healthy) + ' ' +\
 5044            'id: ' + repr(self.id) + ' ' +\
 5045            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5046            'name: ' + repr(self.name) + ' ' +\
 5047            'scopes: ' + repr(self.scopes) + ' ' +\
 5048            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5049            'tags: ' + repr(self.tags) + ' ' +\
 5050            '>'
 5051
 5052    def to_dict(self):
 5053        return {
 5054            'bind_interface': self.bind_interface,
 5055            'egress_filter': self.egress_filter,
 5056            'healthy': self.healthy,
 5057            'id': self.id,
 5058            'keyfile': self.keyfile,
 5059            'name': self.name,
 5060            'scopes': self.scopes,
 5061            'secret_store_id': self.secret_store_id,
 5062            'tags': self.tags,
 5063        }
 5064
 5065    @classmethod
 5066    def from_dict(cls, d):
 5067        return cls(
 5068            bind_interface=d.get('bind_interface'),
 5069            egress_filter=d.get('egress_filter'),
 5070            healthy=d.get('healthy'),
 5071            id=d.get('id'),
 5072            keyfile=d.get('keyfile'),
 5073            name=d.get('name'),
 5074            scopes=d.get('scopes'),
 5075            secret_store_id=d.get('secret_store_id'),
 5076            tags=d.get('tags'),
 5077        )
 5078
 5079
 5080class GCPStore:
 5081    __slots__ = [
 5082        'id',
 5083        'name',
 5084        'projectid',
 5085        'tags',
 5086    ]
 5087
 5088    def __init__(
 5089        self,
 5090        id=None,
 5091        name=None,
 5092        projectid=None,
 5093        tags=None,
 5094    ):
 5095        self.id = id if id is not None else ''
 5096        '''
 5097         Unique identifier of the SecretStore.
 5098        '''
 5099        self.name = name if name is not None else ''
 5100        '''
 5101         Unique human-readable name of the SecretStore.
 5102        '''
 5103        self.projectid = projectid if projectid is not None else ''
 5104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5105        '''
 5106         Tags is a map of key, value pairs.
 5107        '''
 5108
 5109    def __repr__(self):
 5110        return '<sdm.GCPStore ' + \
 5111            'id: ' + repr(self.id) + ' ' +\
 5112            'name: ' + repr(self.name) + ' ' +\
 5113            'projectid: ' + repr(self.projectid) + ' ' +\
 5114            'tags: ' + repr(self.tags) + ' ' +\
 5115            '>'
 5116
 5117    def to_dict(self):
 5118        return {
 5119            'id': self.id,
 5120            'name': self.name,
 5121            'projectid': self.projectid,
 5122            'tags': self.tags,
 5123        }
 5124
 5125    @classmethod
 5126    def from_dict(cls, d):
 5127        return cls(
 5128            id=d.get('id'),
 5129            name=d.get('name'),
 5130            projectid=d.get('projectid'),
 5131            tags=d.get('tags'),
 5132        )
 5133
 5134
 5135class Gateway:
 5136    '''
 5137         Gateway represents a StrongDM CLI installation running in gateway mode.
 5138    '''
 5139    __slots__ = [
 5140        'bind_address',
 5141        'gateway_filter',
 5142        'id',
 5143        'listen_address',
 5144        'name',
 5145        'state',
 5146        'tags',
 5147    ]
 5148
 5149    def __init__(
 5150        self,
 5151        bind_address=None,
 5152        gateway_filter=None,
 5153        id=None,
 5154        listen_address=None,
 5155        name=None,
 5156        state=None,
 5157        tags=None,
 5158    ):
 5159        self.bind_address = bind_address if bind_address is not None else ''
 5160        '''
 5161         The hostname/port tuple which the gateway daemon will bind to.
 5162         If not provided on create, set to "0.0.0.0:listen_address_port".
 5163        '''
 5164        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5165        '''
 5166         GatewayFilter can be used to restrict the peering between relays and
 5167         gateways.
 5168        '''
 5169        self.id = id if id is not None else ''
 5170        '''
 5171         Unique identifier of the Gateway.
 5172        '''
 5173        self.listen_address = listen_address if listen_address is not None else ''
 5174        '''
 5175         The public hostname/port tuple at which the gateway will be accessible to clients.
 5176        '''
 5177        self.name = name if name is not None else ''
 5178        '''
 5179         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5180        '''
 5181        self.state = state if state is not None else ''
 5182        '''
 5183         The current state of the gateway. One of: "new", "verifying_restart",
 5184         "restarting", "started", "stopped", "dead", "unknown"
 5185        '''
 5186        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5187        '''
 5188         Tags is a map of key, value pairs.
 5189        '''
 5190
 5191    def __repr__(self):
 5192        return '<sdm.Gateway ' + \
 5193            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5194            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5195            'id: ' + repr(self.id) + ' ' +\
 5196            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5197            'name: ' + repr(self.name) + ' ' +\
 5198            'state: ' + repr(self.state) + ' ' +\
 5199            'tags: ' + repr(self.tags) + ' ' +\
 5200            '>'
 5201
 5202    def to_dict(self):
 5203        return {
 5204            'bind_address': self.bind_address,
 5205            'gateway_filter': self.gateway_filter,
 5206            'id': self.id,
 5207            'listen_address': self.listen_address,
 5208            'name': self.name,
 5209            'state': self.state,
 5210            'tags': self.tags,
 5211        }
 5212
 5213    @classmethod
 5214    def from_dict(cls, d):
 5215        return cls(
 5216            bind_address=d.get('bind_address'),
 5217            gateway_filter=d.get('gateway_filter'),
 5218            id=d.get('id'),
 5219            listen_address=d.get('listen_address'),
 5220            name=d.get('name'),
 5221            state=d.get('state'),
 5222            tags=d.get('tags'),
 5223        )
 5224
 5225
 5226class GetResponseMetadata:
 5227    '''
 5228         GetResponseMetadata is reserved for future use.
 5229    '''
 5230    __slots__ = []
 5231
 5232    def __init__(self, ):
 5233        pass
 5234
 5235    def __repr__(self):
 5236        return '<sdm.GetResponseMetadata ' + \
 5237            '>'
 5238
 5239    def to_dict(self):
 5240        return {}
 5241
 5242    @classmethod
 5243    def from_dict(cls, d):
 5244        return cls()
 5245
 5246
 5247class GoogleGKE:
 5248    __slots__ = [
 5249        'bind_interface',
 5250        'certificate_authority',
 5251        'egress_filter',
 5252        'endpoint',
 5253        'healthcheck_namespace',
 5254        'healthy',
 5255        'id',
 5256        'name',
 5257        'remote_identity_group_id',
 5258        'remote_identity_healthcheck_username',
 5259        'secret_store_id',
 5260        'service_account_key',
 5261        'tags',
 5262    ]
 5263
 5264    def __init__(
 5265        self,
 5266        bind_interface=None,
 5267        certificate_authority=None,
 5268        egress_filter=None,
 5269        endpoint=None,
 5270        healthcheck_namespace=None,
 5271        healthy=None,
 5272        id=None,
 5273        name=None,
 5274        remote_identity_group_id=None,
 5275        remote_identity_healthcheck_username=None,
 5276        secret_store_id=None,
 5277        service_account_key=None,
 5278        tags=None,
 5279    ):
 5280        self.bind_interface = bind_interface if bind_interface is not None else ''
 5281        '''
 5282         Bind interface
 5283        '''
 5284        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5285        self.egress_filter = egress_filter if egress_filter is not None else ''
 5286        '''
 5287         A filter applied to the routing logic to pin datasource to nodes.
 5288        '''
 5289        self.endpoint = endpoint if endpoint is not None else ''
 5290        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5291        '''
 5292         The path used to check the health of your connection.  Defaults to `default`.
 5293        '''
 5294        self.healthy = healthy if healthy is not None else False
 5295        '''
 5296         True if the datasource is reachable and the credentials are valid.
 5297        '''
 5298        self.id = id if id is not None else ''
 5299        '''
 5300         Unique identifier of the Resource.
 5301        '''
 5302        self.name = name if name is not None else ''
 5303        '''
 5304         Unique human-readable name of the Resource.
 5305        '''
 5306        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5307        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5308        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5309        '''
 5310         ID of the secret store containing credentials for this resource, if any.
 5311        '''
 5312        self.service_account_key = service_account_key if service_account_key is not None else ''
 5313        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5314        '''
 5315         Tags is a map of key, value pairs.
 5316        '''
 5317
 5318    def __repr__(self):
 5319        return '<sdm.GoogleGKE ' + \
 5320            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5321            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5322            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5323            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5324            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5325            'healthy: ' + repr(self.healthy) + ' ' +\
 5326            'id: ' + repr(self.id) + ' ' +\
 5327            'name: ' + repr(self.name) + ' ' +\
 5328            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5329            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5330            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5331            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5332            'tags: ' + repr(self.tags) + ' ' +\
 5333            '>'
 5334
 5335    def to_dict(self):
 5336        return {
 5337            'bind_interface': self.bind_interface,
 5338            'certificate_authority': self.certificate_authority,
 5339            'egress_filter': self.egress_filter,
 5340            'endpoint': self.endpoint,
 5341            'healthcheck_namespace': self.healthcheck_namespace,
 5342            'healthy': self.healthy,
 5343            'id': self.id,
 5344            'name': self.name,
 5345            'remote_identity_group_id': self.remote_identity_group_id,
 5346            'remote_identity_healthcheck_username':
 5347            self.remote_identity_healthcheck_username,
 5348            'secret_store_id': self.secret_store_id,
 5349            'service_account_key': self.service_account_key,
 5350            'tags': self.tags,
 5351        }
 5352
 5353    @classmethod
 5354    def from_dict(cls, d):
 5355        return cls(
 5356            bind_interface=d.get('bind_interface'),
 5357            certificate_authority=d.get('certificate_authority'),
 5358            egress_filter=d.get('egress_filter'),
 5359            endpoint=d.get('endpoint'),
 5360            healthcheck_namespace=d.get('healthcheck_namespace'),
 5361            healthy=d.get('healthy'),
 5362            id=d.get('id'),
 5363            name=d.get('name'),
 5364            remote_identity_group_id=d.get('remote_identity_group_id'),
 5365            remote_identity_healthcheck_username=d.get(
 5366                'remote_identity_healthcheck_username'),
 5367            secret_store_id=d.get('secret_store_id'),
 5368            service_account_key=d.get('service_account_key'),
 5369            tags=d.get('tags'),
 5370        )
 5371
 5372
 5373class GoogleGKEUserImpersonation:
 5374    __slots__ = [
 5375        'bind_interface',
 5376        'certificate_authority',
 5377        'egress_filter',
 5378        'endpoint',
 5379        'healthcheck_namespace',
 5380        'healthy',
 5381        'id',
 5382        'name',
 5383        'secret_store_id',
 5384        'service_account_key',
 5385        'tags',
 5386    ]
 5387
 5388    def __init__(
 5389        self,
 5390        bind_interface=None,
 5391        certificate_authority=None,
 5392        egress_filter=None,
 5393        endpoint=None,
 5394        healthcheck_namespace=None,
 5395        healthy=None,
 5396        id=None,
 5397        name=None,
 5398        secret_store_id=None,
 5399        service_account_key=None,
 5400        tags=None,
 5401    ):
 5402        self.bind_interface = bind_interface if bind_interface is not None else ''
 5403        '''
 5404         Bind interface
 5405        '''
 5406        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5407        self.egress_filter = egress_filter if egress_filter is not None else ''
 5408        '''
 5409         A filter applied to the routing logic to pin datasource to nodes.
 5410        '''
 5411        self.endpoint = endpoint if endpoint is not None else ''
 5412        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5413        '''
 5414         The path used to check the health of your connection.  Defaults to `default`.
 5415        '''
 5416        self.healthy = healthy if healthy is not None else False
 5417        '''
 5418         True if the datasource is reachable and the credentials are valid.
 5419        '''
 5420        self.id = id if id is not None else ''
 5421        '''
 5422         Unique identifier of the Resource.
 5423        '''
 5424        self.name = name if name is not None else ''
 5425        '''
 5426         Unique human-readable name of the Resource.
 5427        '''
 5428        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5429        '''
 5430         ID of the secret store containing credentials for this resource, if any.
 5431        '''
 5432        self.service_account_key = service_account_key if service_account_key is not None else ''
 5433        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5434        '''
 5435         Tags is a map of key, value pairs.
 5436        '''
 5437
 5438    def __repr__(self):
 5439        return '<sdm.GoogleGKEUserImpersonation ' + \
 5440            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5441            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5442            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5443            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5444            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5445            'healthy: ' + repr(self.healthy) + ' ' +\
 5446            'id: ' + repr(self.id) + ' ' +\
 5447            'name: ' + repr(self.name) + ' ' +\
 5448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5449            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5450            'tags: ' + repr(self.tags) + ' ' +\
 5451            '>'
 5452
 5453    def to_dict(self):
 5454        return {
 5455            'bind_interface': self.bind_interface,
 5456            'certificate_authority': self.certificate_authority,
 5457            'egress_filter': self.egress_filter,
 5458            'endpoint': self.endpoint,
 5459            'healthcheck_namespace': self.healthcheck_namespace,
 5460            'healthy': self.healthy,
 5461            'id': self.id,
 5462            'name': self.name,
 5463            'secret_store_id': self.secret_store_id,
 5464            'service_account_key': self.service_account_key,
 5465            'tags': self.tags,
 5466        }
 5467
 5468    @classmethod
 5469    def from_dict(cls, d):
 5470        return cls(
 5471            bind_interface=d.get('bind_interface'),
 5472            certificate_authority=d.get('certificate_authority'),
 5473            egress_filter=d.get('egress_filter'),
 5474            endpoint=d.get('endpoint'),
 5475            healthcheck_namespace=d.get('healthcheck_namespace'),
 5476            healthy=d.get('healthy'),
 5477            id=d.get('id'),
 5478            name=d.get('name'),
 5479            secret_store_id=d.get('secret_store_id'),
 5480            service_account_key=d.get('service_account_key'),
 5481            tags=d.get('tags'),
 5482        )
 5483
 5484
 5485class Greenplum:
 5486    __slots__ = [
 5487        'bind_interface',
 5488        'database',
 5489        'egress_filter',
 5490        'healthy',
 5491        'hostname',
 5492        'id',
 5493        'name',
 5494        'override_database',
 5495        'password',
 5496        'port',
 5497        'port_override',
 5498        'secret_store_id',
 5499        'tags',
 5500        'username',
 5501    ]
 5502
 5503    def __init__(
 5504        self,
 5505        bind_interface=None,
 5506        database=None,
 5507        egress_filter=None,
 5508        healthy=None,
 5509        hostname=None,
 5510        id=None,
 5511        name=None,
 5512        override_database=None,
 5513        password=None,
 5514        port=None,
 5515        port_override=None,
 5516        secret_store_id=None,
 5517        tags=None,
 5518        username=None,
 5519    ):
 5520        self.bind_interface = bind_interface if bind_interface is not None else ''
 5521        '''
 5522         Bind interface
 5523        '''
 5524        self.database = database if database is not None else ''
 5525        self.egress_filter = egress_filter if egress_filter is not None else ''
 5526        '''
 5527         A filter applied to the routing logic to pin datasource to nodes.
 5528        '''
 5529        self.healthy = healthy if healthy is not None else False
 5530        '''
 5531         True if the datasource is reachable and the credentials are valid.
 5532        '''
 5533        self.hostname = hostname if hostname is not None else ''
 5534        self.id = id if id is not None else ''
 5535        '''
 5536         Unique identifier of the Resource.
 5537        '''
 5538        self.name = name if name is not None else ''
 5539        '''
 5540         Unique human-readable name of the Resource.
 5541        '''
 5542        self.override_database = override_database if override_database is not None else False
 5543        self.password = password if password is not None else ''
 5544        self.port = port if port is not None else 0
 5545        self.port_override = port_override if port_override is not None else 0
 5546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5547        '''
 5548         ID of the secret store containing credentials for this resource, if any.
 5549        '''
 5550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5551        '''
 5552         Tags is a map of key, value pairs.
 5553        '''
 5554        self.username = username if username is not None else ''
 5555
 5556    def __repr__(self):
 5557        return '<sdm.Greenplum ' + \
 5558            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5559            'database: ' + repr(self.database) + ' ' +\
 5560            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5561            'healthy: ' + repr(self.healthy) + ' ' +\
 5562            'hostname: ' + repr(self.hostname) + ' ' +\
 5563            'id: ' + repr(self.id) + ' ' +\
 5564            'name: ' + repr(self.name) + ' ' +\
 5565            'override_database: ' + repr(self.override_database) + ' ' +\
 5566            'password: ' + repr(self.password) + ' ' +\
 5567            'port: ' + repr(self.port) + ' ' +\
 5568            'port_override: ' + repr(self.port_override) + ' ' +\
 5569            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5570            'tags: ' + repr(self.tags) + ' ' +\
 5571            'username: ' + repr(self.username) + ' ' +\
 5572            '>'
 5573
 5574    def to_dict(self):
 5575        return {
 5576            'bind_interface': self.bind_interface,
 5577            'database': self.database,
 5578            'egress_filter': self.egress_filter,
 5579            'healthy': self.healthy,
 5580            'hostname': self.hostname,
 5581            'id': self.id,
 5582            'name': self.name,
 5583            'override_database': self.override_database,
 5584            'password': self.password,
 5585            'port': self.port,
 5586            'port_override': self.port_override,
 5587            'secret_store_id': self.secret_store_id,
 5588            'tags': self.tags,
 5589            'username': self.username,
 5590        }
 5591
 5592    @classmethod
 5593    def from_dict(cls, d):
 5594        return cls(
 5595            bind_interface=d.get('bind_interface'),
 5596            database=d.get('database'),
 5597            egress_filter=d.get('egress_filter'),
 5598            healthy=d.get('healthy'),
 5599            hostname=d.get('hostname'),
 5600            id=d.get('id'),
 5601            name=d.get('name'),
 5602            override_database=d.get('override_database'),
 5603            password=d.get('password'),
 5604            port=d.get('port'),
 5605            port_override=d.get('port_override'),
 5606            secret_store_id=d.get('secret_store_id'),
 5607            tags=d.get('tags'),
 5608            username=d.get('username'),
 5609        )
 5610
 5611
 5612class HTTPAuth:
 5613    __slots__ = [
 5614        'auth_header',
 5615        'bind_interface',
 5616        'default_path',
 5617        'egress_filter',
 5618        'headers_blacklist',
 5619        'healthcheck_path',
 5620        'healthy',
 5621        'host_override',
 5622        'id',
 5623        'name',
 5624        'secret_store_id',
 5625        'subdomain',
 5626        'tags',
 5627        'url',
 5628    ]
 5629
 5630    def __init__(
 5631        self,
 5632        auth_header=None,
 5633        bind_interface=None,
 5634        default_path=None,
 5635        egress_filter=None,
 5636        headers_blacklist=None,
 5637        healthcheck_path=None,
 5638        healthy=None,
 5639        host_override=None,
 5640        id=None,
 5641        name=None,
 5642        secret_store_id=None,
 5643        subdomain=None,
 5644        tags=None,
 5645        url=None,
 5646    ):
 5647        self.auth_header = auth_header if auth_header is not None else ''
 5648        self.bind_interface = bind_interface if bind_interface is not None else ''
 5649        '''
 5650         Bind interface
 5651        '''
 5652        self.default_path = default_path if default_path is not None else ''
 5653        self.egress_filter = egress_filter if egress_filter is not None else ''
 5654        '''
 5655         A filter applied to the routing logic to pin datasource to nodes.
 5656        '''
 5657        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5658        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5659        self.healthy = healthy if healthy is not None else False
 5660        '''
 5661         True if the datasource is reachable and the credentials are valid.
 5662        '''
 5663        self.host_override = host_override if host_override is not None else ''
 5664        self.id = id if id is not None else ''
 5665        '''
 5666         Unique identifier of the Resource.
 5667        '''
 5668        self.name = name if name is not None else ''
 5669        '''
 5670         Unique human-readable name of the Resource.
 5671        '''
 5672        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5673        '''
 5674         ID of the secret store containing credentials for this resource, if any.
 5675        '''
 5676        self.subdomain = subdomain if subdomain is not None else ''
 5677        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5678        '''
 5679         Tags is a map of key, value pairs.
 5680        '''
 5681        self.url = url if url is not None else ''
 5682
 5683    def __repr__(self):
 5684        return '<sdm.HTTPAuth ' + \
 5685            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5686            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5687            'default_path: ' + repr(self.default_path) + ' ' +\
 5688            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5689            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5690            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5691            'healthy: ' + repr(self.healthy) + ' ' +\
 5692            'host_override: ' + repr(self.host_override) + ' ' +\
 5693            'id: ' + repr(self.id) + ' ' +\
 5694            'name: ' + repr(self.name) + ' ' +\
 5695            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5696            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5697            'tags: ' + repr(self.tags) + ' ' +\
 5698            'url: ' + repr(self.url) + ' ' +\
 5699            '>'
 5700
 5701    def to_dict(self):
 5702        return {
 5703            'auth_header': self.auth_header,
 5704            'bind_interface': self.bind_interface,
 5705            'default_path': self.default_path,
 5706            'egress_filter': self.egress_filter,
 5707            'headers_blacklist': self.headers_blacklist,
 5708            'healthcheck_path': self.healthcheck_path,
 5709            'healthy': self.healthy,
 5710            'host_override': self.host_override,
 5711            'id': self.id,
 5712            'name': self.name,
 5713            'secret_store_id': self.secret_store_id,
 5714            'subdomain': self.subdomain,
 5715            'tags': self.tags,
 5716            'url': self.url,
 5717        }
 5718
 5719    @classmethod
 5720    def from_dict(cls, d):
 5721        return cls(
 5722            auth_header=d.get('auth_header'),
 5723            bind_interface=d.get('bind_interface'),
 5724            default_path=d.get('default_path'),
 5725            egress_filter=d.get('egress_filter'),
 5726            headers_blacklist=d.get('headers_blacklist'),
 5727            healthcheck_path=d.get('healthcheck_path'),
 5728            healthy=d.get('healthy'),
 5729            host_override=d.get('host_override'),
 5730            id=d.get('id'),
 5731            name=d.get('name'),
 5732            secret_store_id=d.get('secret_store_id'),
 5733            subdomain=d.get('subdomain'),
 5734            tags=d.get('tags'),
 5735            url=d.get('url'),
 5736        )
 5737
 5738
 5739class HTTPBasicAuth:
 5740    __slots__ = [
 5741        'bind_interface',
 5742        'default_path',
 5743        'egress_filter',
 5744        'headers_blacklist',
 5745        'healthcheck_path',
 5746        'healthy',
 5747        'host_override',
 5748        'id',
 5749        'name',
 5750        'password',
 5751        'secret_store_id',
 5752        'subdomain',
 5753        'tags',
 5754        'url',
 5755        'username',
 5756    ]
 5757
 5758    def __init__(
 5759        self,
 5760        bind_interface=None,
 5761        default_path=None,
 5762        egress_filter=None,
 5763        headers_blacklist=None,
 5764        healthcheck_path=None,
 5765        healthy=None,
 5766        host_override=None,
 5767        id=None,
 5768        name=None,
 5769        password=None,
 5770        secret_store_id=None,
 5771        subdomain=None,
 5772        tags=None,
 5773        url=None,
 5774        username=None,
 5775    ):
 5776        self.bind_interface = bind_interface if bind_interface is not None else ''
 5777        '''
 5778         Bind interface
 5779        '''
 5780        self.default_path = default_path if default_path is not None else ''
 5781        self.egress_filter = egress_filter if egress_filter is not None else ''
 5782        '''
 5783         A filter applied to the routing logic to pin datasource to nodes.
 5784        '''
 5785        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5786        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5787        self.healthy = healthy if healthy is not None else False
 5788        '''
 5789         True if the datasource is reachable and the credentials are valid.
 5790        '''
 5791        self.host_override = host_override if host_override is not None else ''
 5792        self.id = id if id is not None else ''
 5793        '''
 5794         Unique identifier of the Resource.
 5795        '''
 5796        self.name = name if name is not None else ''
 5797        '''
 5798         Unique human-readable name of the Resource.
 5799        '''
 5800        self.password = password if password is not None else ''
 5801        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5802        '''
 5803         ID of the secret store containing credentials for this resource, if any.
 5804        '''
 5805        self.subdomain = subdomain if subdomain is not None else ''
 5806        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5807        '''
 5808         Tags is a map of key, value pairs.
 5809        '''
 5810        self.url = url if url is not None else ''
 5811        self.username = username if username is not None else ''
 5812
 5813    def __repr__(self):
 5814        return '<sdm.HTTPBasicAuth ' + \
 5815            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5816            'default_path: ' + repr(self.default_path) + ' ' +\
 5817            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5818            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5819            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5820            'healthy: ' + repr(self.healthy) + ' ' +\
 5821            'host_override: ' + repr(self.host_override) + ' ' +\
 5822            'id: ' + repr(self.id) + ' ' +\
 5823            'name: ' + repr(self.name) + ' ' +\
 5824            'password: ' + repr(self.password) + ' ' +\
 5825            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5826            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5827            'tags: ' + repr(self.tags) + ' ' +\
 5828            'url: ' + repr(self.url) + ' ' +\
 5829            'username: ' + repr(self.username) + ' ' +\
 5830            '>'
 5831
 5832    def to_dict(self):
 5833        return {
 5834            'bind_interface': self.bind_interface,
 5835            'default_path': self.default_path,
 5836            'egress_filter': self.egress_filter,
 5837            'headers_blacklist': self.headers_blacklist,
 5838            'healthcheck_path': self.healthcheck_path,
 5839            'healthy': self.healthy,
 5840            'host_override': self.host_override,
 5841            'id': self.id,
 5842            'name': self.name,
 5843            'password': self.password,
 5844            'secret_store_id': self.secret_store_id,
 5845            'subdomain': self.subdomain,
 5846            'tags': self.tags,
 5847            'url': self.url,
 5848            'username': self.username,
 5849        }
 5850
 5851    @classmethod
 5852    def from_dict(cls, d):
 5853        return cls(
 5854            bind_interface=d.get('bind_interface'),
 5855            default_path=d.get('default_path'),
 5856            egress_filter=d.get('egress_filter'),
 5857            headers_blacklist=d.get('headers_blacklist'),
 5858            healthcheck_path=d.get('healthcheck_path'),
 5859            healthy=d.get('healthy'),
 5860            host_override=d.get('host_override'),
 5861            id=d.get('id'),
 5862            name=d.get('name'),
 5863            password=d.get('password'),
 5864            secret_store_id=d.get('secret_store_id'),
 5865            subdomain=d.get('subdomain'),
 5866            tags=d.get('tags'),
 5867            url=d.get('url'),
 5868            username=d.get('username'),
 5869        )
 5870
 5871
 5872class HTTPNoAuth:
 5873    __slots__ = [
 5874        'bind_interface',
 5875        'default_path',
 5876        'egress_filter',
 5877        'headers_blacklist',
 5878        'healthcheck_path',
 5879        'healthy',
 5880        'host_override',
 5881        'id',
 5882        'name',
 5883        'secret_store_id',
 5884        'subdomain',
 5885        'tags',
 5886        'url',
 5887    ]
 5888
 5889    def __init__(
 5890        self,
 5891        bind_interface=None,
 5892        default_path=None,
 5893        egress_filter=None,
 5894        headers_blacklist=None,
 5895        healthcheck_path=None,
 5896        healthy=None,
 5897        host_override=None,
 5898        id=None,
 5899        name=None,
 5900        secret_store_id=None,
 5901        subdomain=None,
 5902        tags=None,
 5903        url=None,
 5904    ):
 5905        self.bind_interface = bind_interface if bind_interface is not None else ''
 5906        '''
 5907         Bind interface
 5908        '''
 5909        self.default_path = default_path if default_path is not None else ''
 5910        self.egress_filter = egress_filter if egress_filter is not None else ''
 5911        '''
 5912         A filter applied to the routing logic to pin datasource to nodes.
 5913        '''
 5914        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5915        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5916        self.healthy = healthy if healthy is not None else False
 5917        '''
 5918         True if the datasource is reachable and the credentials are valid.
 5919        '''
 5920        self.host_override = host_override if host_override is not None else ''
 5921        self.id = id if id is not None else ''
 5922        '''
 5923         Unique identifier of the Resource.
 5924        '''
 5925        self.name = name if name is not None else ''
 5926        '''
 5927         Unique human-readable name of the Resource.
 5928        '''
 5929        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5930        '''
 5931         ID of the secret store containing credentials for this resource, if any.
 5932        '''
 5933        self.subdomain = subdomain if subdomain is not None else ''
 5934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5935        '''
 5936         Tags is a map of key, value pairs.
 5937        '''
 5938        self.url = url if url is not None else ''
 5939
 5940    def __repr__(self):
 5941        return '<sdm.HTTPNoAuth ' + \
 5942            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5943            'default_path: ' + repr(self.default_path) + ' ' +\
 5944            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5945            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5946            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5947            'healthy: ' + repr(self.healthy) + ' ' +\
 5948            'host_override: ' + repr(self.host_override) + ' ' +\
 5949            'id: ' + repr(self.id) + ' ' +\
 5950            'name: ' + repr(self.name) + ' ' +\
 5951            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5952            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5953            'tags: ' + repr(self.tags) + ' ' +\
 5954            'url: ' + repr(self.url) + ' ' +\
 5955            '>'
 5956
 5957    def to_dict(self):
 5958        return {
 5959            'bind_interface': self.bind_interface,
 5960            'default_path': self.default_path,
 5961            'egress_filter': self.egress_filter,
 5962            'headers_blacklist': self.headers_blacklist,
 5963            'healthcheck_path': self.healthcheck_path,
 5964            'healthy': self.healthy,
 5965            'host_override': self.host_override,
 5966            'id': self.id,
 5967            'name': self.name,
 5968            'secret_store_id': self.secret_store_id,
 5969            'subdomain': self.subdomain,
 5970            'tags': self.tags,
 5971            'url': self.url,
 5972        }
 5973
 5974    @classmethod
 5975    def from_dict(cls, d):
 5976        return cls(
 5977            bind_interface=d.get('bind_interface'),
 5978            default_path=d.get('default_path'),
 5979            egress_filter=d.get('egress_filter'),
 5980            headers_blacklist=d.get('headers_blacklist'),
 5981            healthcheck_path=d.get('healthcheck_path'),
 5982            healthy=d.get('healthy'),
 5983            host_override=d.get('host_override'),
 5984            id=d.get('id'),
 5985            name=d.get('name'),
 5986            secret_store_id=d.get('secret_store_id'),
 5987            subdomain=d.get('subdomain'),
 5988            tags=d.get('tags'),
 5989            url=d.get('url'),
 5990        )
 5991
 5992
 5993class Kubernetes:
 5994    __slots__ = [
 5995        'bind_interface',
 5996        'certificate_authority',
 5997        'client_certificate',
 5998        'client_key',
 5999        'egress_filter',
 6000        'healthcheck_namespace',
 6001        'healthy',
 6002        'hostname',
 6003        'id',
 6004        'name',
 6005        'port',
 6006        'port_override',
 6007        'remote_identity_group_id',
 6008        'remote_identity_healthcheck_username',
 6009        'secret_store_id',
 6010        'tags',
 6011    ]
 6012
 6013    def __init__(
 6014        self,
 6015        bind_interface=None,
 6016        certificate_authority=None,
 6017        client_certificate=None,
 6018        client_key=None,
 6019        egress_filter=None,
 6020        healthcheck_namespace=None,
 6021        healthy=None,
 6022        hostname=None,
 6023        id=None,
 6024        name=None,
 6025        port=None,
 6026        port_override=None,
 6027        remote_identity_group_id=None,
 6028        remote_identity_healthcheck_username=None,
 6029        secret_store_id=None,
 6030        tags=None,
 6031    ):
 6032        self.bind_interface = bind_interface if bind_interface is not None else ''
 6033        '''
 6034         Bind interface
 6035        '''
 6036        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6037        self.client_certificate = client_certificate if client_certificate is not None else ''
 6038        self.client_key = client_key if client_key is not None else ''
 6039        self.egress_filter = egress_filter if egress_filter is not None else ''
 6040        '''
 6041         A filter applied to the routing logic to pin datasource to nodes.
 6042        '''
 6043        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6044        '''
 6045         The path used to check the health of your connection.  Defaults to `default`.
 6046        '''
 6047        self.healthy = healthy if healthy is not None else False
 6048        '''
 6049         True if the datasource is reachable and the credentials are valid.
 6050        '''
 6051        self.hostname = hostname if hostname is not None else ''
 6052        self.id = id if id is not None else ''
 6053        '''
 6054         Unique identifier of the Resource.
 6055        '''
 6056        self.name = name if name is not None else ''
 6057        '''
 6058         Unique human-readable name of the Resource.
 6059        '''
 6060        self.port = port if port is not None else 0
 6061        self.port_override = port_override if port_override is not None else 0
 6062        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6063        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6064        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6065        '''
 6066         ID of the secret store containing credentials for this resource, if any.
 6067        '''
 6068        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6069        '''
 6070         Tags is a map of key, value pairs.
 6071        '''
 6072
 6073    def __repr__(self):
 6074        return '<sdm.Kubernetes ' + \
 6075            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6076            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6077            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6078            'client_key: ' + repr(self.client_key) + ' ' +\
 6079            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6080            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6081            'healthy: ' + repr(self.healthy) + ' ' +\
 6082            'hostname: ' + repr(self.hostname) + ' ' +\
 6083            'id: ' + repr(self.id) + ' ' +\
 6084            'name: ' + repr(self.name) + ' ' +\
 6085            'port: ' + repr(self.port) + ' ' +\
 6086            'port_override: ' + repr(self.port_override) + ' ' +\
 6087            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6088            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6089            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6090            'tags: ' + repr(self.tags) + ' ' +\
 6091            '>'
 6092
 6093    def to_dict(self):
 6094        return {
 6095            'bind_interface': self.bind_interface,
 6096            'certificate_authority': self.certificate_authority,
 6097            'client_certificate': self.client_certificate,
 6098            'client_key': self.client_key,
 6099            'egress_filter': self.egress_filter,
 6100            'healthcheck_namespace': self.healthcheck_namespace,
 6101            'healthy': self.healthy,
 6102            'hostname': self.hostname,
 6103            'id': self.id,
 6104            'name': self.name,
 6105            'port': self.port,
 6106            'port_override': self.port_override,
 6107            'remote_identity_group_id': self.remote_identity_group_id,
 6108            'remote_identity_healthcheck_username':
 6109            self.remote_identity_healthcheck_username,
 6110            'secret_store_id': self.secret_store_id,
 6111            'tags': self.tags,
 6112        }
 6113
 6114    @classmethod
 6115    def from_dict(cls, d):
 6116        return cls(
 6117            bind_interface=d.get('bind_interface'),
 6118            certificate_authority=d.get('certificate_authority'),
 6119            client_certificate=d.get('client_certificate'),
 6120            client_key=d.get('client_key'),
 6121            egress_filter=d.get('egress_filter'),
 6122            healthcheck_namespace=d.get('healthcheck_namespace'),
 6123            healthy=d.get('healthy'),
 6124            hostname=d.get('hostname'),
 6125            id=d.get('id'),
 6126            name=d.get('name'),
 6127            port=d.get('port'),
 6128            port_override=d.get('port_override'),
 6129            remote_identity_group_id=d.get('remote_identity_group_id'),
 6130            remote_identity_healthcheck_username=d.get(
 6131                'remote_identity_healthcheck_username'),
 6132            secret_store_id=d.get('secret_store_id'),
 6133            tags=d.get('tags'),
 6134        )
 6135
 6136
 6137class KubernetesBasicAuth:
 6138    __slots__ = [
 6139        'bind_interface',
 6140        'egress_filter',
 6141        'healthcheck_namespace',
 6142        'healthy',
 6143        'hostname',
 6144        'id',
 6145        'name',
 6146        'password',
 6147        'port',
 6148        'port_override',
 6149        'secret_store_id',
 6150        'tags',
 6151        'username',
 6152    ]
 6153
 6154    def __init__(
 6155        self,
 6156        bind_interface=None,
 6157        egress_filter=None,
 6158        healthcheck_namespace=None,
 6159        healthy=None,
 6160        hostname=None,
 6161        id=None,
 6162        name=None,
 6163        password=None,
 6164        port=None,
 6165        port_override=None,
 6166        secret_store_id=None,
 6167        tags=None,
 6168        username=None,
 6169    ):
 6170        self.bind_interface = bind_interface if bind_interface is not None else ''
 6171        '''
 6172         Bind interface
 6173        '''
 6174        self.egress_filter = egress_filter if egress_filter is not None else ''
 6175        '''
 6176         A filter applied to the routing logic to pin datasource to nodes.
 6177        '''
 6178        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6179        '''
 6180         The path used to check the health of your connection.  Defaults to `default`.
 6181        '''
 6182        self.healthy = healthy if healthy is not None else False
 6183        '''
 6184         True if the datasource is reachable and the credentials are valid.
 6185        '''
 6186        self.hostname = hostname if hostname is not None else ''
 6187        self.id = id if id is not None else ''
 6188        '''
 6189         Unique identifier of the Resource.
 6190        '''
 6191        self.name = name if name is not None else ''
 6192        '''
 6193         Unique human-readable name of the Resource.
 6194        '''
 6195        self.password = password if password is not None else ''
 6196        self.port = port if port is not None else 0
 6197        self.port_override = port_override if port_override is not None else 0
 6198        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6199        '''
 6200         ID of the secret store containing credentials for this resource, if any.
 6201        '''
 6202        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6203        '''
 6204         Tags is a map of key, value pairs.
 6205        '''
 6206        self.username = username if username is not None else ''
 6207
 6208    def __repr__(self):
 6209        return '<sdm.KubernetesBasicAuth ' + \
 6210            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6212            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6213            'healthy: ' + repr(self.healthy) + ' ' +\
 6214            'hostname: ' + repr(self.hostname) + ' ' +\
 6215            'id: ' + repr(self.id) + ' ' +\
 6216            'name: ' + repr(self.name) + ' ' +\
 6217            'password: ' + repr(self.password) + ' ' +\
 6218            'port: ' + repr(self.port) + ' ' +\
 6219            'port_override: ' + repr(self.port_override) + ' ' +\
 6220            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6221            'tags: ' + repr(self.tags) + ' ' +\
 6222            'username: ' + repr(self.username) + ' ' +\
 6223            '>'
 6224
 6225    def to_dict(self):
 6226        return {
 6227            'bind_interface': self.bind_interface,
 6228            'egress_filter': self.egress_filter,
 6229            'healthcheck_namespace': self.healthcheck_namespace,
 6230            'healthy': self.healthy,
 6231            'hostname': self.hostname,
 6232            'id': self.id,
 6233            'name': self.name,
 6234            'password': self.password,
 6235            'port': self.port,
 6236            'port_override': self.port_override,
 6237            'secret_store_id': self.secret_store_id,
 6238            'tags': self.tags,
 6239            'username': self.username,
 6240        }
 6241
 6242    @classmethod
 6243    def from_dict(cls, d):
 6244        return cls(
 6245            bind_interface=d.get('bind_interface'),
 6246            egress_filter=d.get('egress_filter'),
 6247            healthcheck_namespace=d.get('healthcheck_namespace'),
 6248            healthy=d.get('healthy'),
 6249            hostname=d.get('hostname'),
 6250            id=d.get('id'),
 6251            name=d.get('name'),
 6252            password=d.get('password'),
 6253            port=d.get('port'),
 6254            port_override=d.get('port_override'),
 6255            secret_store_id=d.get('secret_store_id'),
 6256            tags=d.get('tags'),
 6257            username=d.get('username'),
 6258        )
 6259
 6260
 6261class KubernetesServiceAccount:
 6262    __slots__ = [
 6263        'bind_interface',
 6264        'egress_filter',
 6265        'healthcheck_namespace',
 6266        'healthy',
 6267        'hostname',
 6268        'id',
 6269        'name',
 6270        'port',
 6271        'port_override',
 6272        'remote_identity_group_id',
 6273        'remote_identity_healthcheck_username',
 6274        'secret_store_id',
 6275        'tags',
 6276        'token',
 6277    ]
 6278
 6279    def __init__(
 6280        self,
 6281        bind_interface=None,
 6282        egress_filter=None,
 6283        healthcheck_namespace=None,
 6284        healthy=None,
 6285        hostname=None,
 6286        id=None,
 6287        name=None,
 6288        port=None,
 6289        port_override=None,
 6290        remote_identity_group_id=None,
 6291        remote_identity_healthcheck_username=None,
 6292        secret_store_id=None,
 6293        tags=None,
 6294        token=None,
 6295    ):
 6296        self.bind_interface = bind_interface if bind_interface is not None else ''
 6297        '''
 6298         Bind interface
 6299        '''
 6300        self.egress_filter = egress_filter if egress_filter is not None else ''
 6301        '''
 6302         A filter applied to the routing logic to pin datasource to nodes.
 6303        '''
 6304        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6305        '''
 6306         The path used to check the health of your connection.  Defaults to `default`.
 6307        '''
 6308        self.healthy = healthy if healthy is not None else False
 6309        '''
 6310         True if the datasource is reachable and the credentials are valid.
 6311        '''
 6312        self.hostname = hostname if hostname is not None else ''
 6313        self.id = id if id is not None else ''
 6314        '''
 6315         Unique identifier of the Resource.
 6316        '''
 6317        self.name = name if name is not None else ''
 6318        '''
 6319         Unique human-readable name of the Resource.
 6320        '''
 6321        self.port = port if port is not None else 0
 6322        self.port_override = port_override if port_override is not None else 0
 6323        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6324        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6325        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6326        '''
 6327         ID of the secret store containing credentials for this resource, if any.
 6328        '''
 6329        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6330        '''
 6331         Tags is a map of key, value pairs.
 6332        '''
 6333        self.token = token if token is not None else ''
 6334
 6335    def __repr__(self):
 6336        return '<sdm.KubernetesServiceAccount ' + \
 6337            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6338            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6339            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6340            'healthy: ' + repr(self.healthy) + ' ' +\
 6341            'hostname: ' + repr(self.hostname) + ' ' +\
 6342            'id: ' + repr(self.id) + ' ' +\
 6343            'name: ' + repr(self.name) + ' ' +\
 6344            'port: ' + repr(self.port) + ' ' +\
 6345            'port_override: ' + repr(self.port_override) + ' ' +\
 6346            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6347            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6348            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6349            'tags: ' + repr(self.tags) + ' ' +\
 6350            'token: ' + repr(self.token) + ' ' +\
 6351            '>'
 6352
 6353    def to_dict(self):
 6354        return {
 6355            'bind_interface': self.bind_interface,
 6356            'egress_filter': self.egress_filter,
 6357            'healthcheck_namespace': self.healthcheck_namespace,
 6358            'healthy': self.healthy,
 6359            'hostname': self.hostname,
 6360            'id': self.id,
 6361            'name': self.name,
 6362            'port': self.port,
 6363            'port_override': self.port_override,
 6364            'remote_identity_group_id': self.remote_identity_group_id,
 6365            'remote_identity_healthcheck_username':
 6366            self.remote_identity_healthcheck_username,
 6367            'secret_store_id': self.secret_store_id,
 6368            'tags': self.tags,
 6369            'token': self.token,
 6370        }
 6371
 6372    @classmethod
 6373    def from_dict(cls, d):
 6374        return cls(
 6375            bind_interface=d.get('bind_interface'),
 6376            egress_filter=d.get('egress_filter'),
 6377            healthcheck_namespace=d.get('healthcheck_namespace'),
 6378            healthy=d.get('healthy'),
 6379            hostname=d.get('hostname'),
 6380            id=d.get('id'),
 6381            name=d.get('name'),
 6382            port=d.get('port'),
 6383            port_override=d.get('port_override'),
 6384            remote_identity_group_id=d.get('remote_identity_group_id'),
 6385            remote_identity_healthcheck_username=d.get(
 6386                'remote_identity_healthcheck_username'),
 6387            secret_store_id=d.get('secret_store_id'),
 6388            tags=d.get('tags'),
 6389            token=d.get('token'),
 6390        )
 6391
 6392
 6393class KubernetesServiceAccountUserImpersonation:
 6394    __slots__ = [
 6395        'bind_interface',
 6396        'egress_filter',
 6397        'healthcheck_namespace',
 6398        'healthy',
 6399        'hostname',
 6400        'id',
 6401        'name',
 6402        'port',
 6403        'port_override',
 6404        'secret_store_id',
 6405        'tags',
 6406        'token',
 6407    ]
 6408
 6409    def __init__(
 6410        self,
 6411        bind_interface=None,
 6412        egress_filter=None,
 6413        healthcheck_namespace=None,
 6414        healthy=None,
 6415        hostname=None,
 6416        id=None,
 6417        name=None,
 6418        port=None,
 6419        port_override=None,
 6420        secret_store_id=None,
 6421        tags=None,
 6422        token=None,
 6423    ):
 6424        self.bind_interface = bind_interface if bind_interface is not None else ''
 6425        '''
 6426         Bind interface
 6427        '''
 6428        self.egress_filter = egress_filter if egress_filter is not None else ''
 6429        '''
 6430         A filter applied to the routing logic to pin datasource to nodes.
 6431        '''
 6432        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6433        '''
 6434         The path used to check the health of your connection.  Defaults to `default`.
 6435        '''
 6436        self.healthy = healthy if healthy is not None else False
 6437        '''
 6438         True if the datasource is reachable and the credentials are valid.
 6439        '''
 6440        self.hostname = hostname if hostname is not None else ''
 6441        self.id = id if id is not None else ''
 6442        '''
 6443         Unique identifier of the Resource.
 6444        '''
 6445        self.name = name if name is not None else ''
 6446        '''
 6447         Unique human-readable name of the Resource.
 6448        '''
 6449        self.port = port if port is not None else 0
 6450        self.port_override = port_override if port_override is not None else 0
 6451        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6452        '''
 6453         ID of the secret store containing credentials for this resource, if any.
 6454        '''
 6455        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6456        '''
 6457         Tags is a map of key, value pairs.
 6458        '''
 6459        self.token = token if token is not None else ''
 6460
 6461    def __repr__(self):
 6462        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6464            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6465            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6466            'healthy: ' + repr(self.healthy) + ' ' +\
 6467            'hostname: ' + repr(self.hostname) + ' ' +\
 6468            'id: ' + repr(self.id) + ' ' +\
 6469            'name: ' + repr(self.name) + ' ' +\
 6470            'port: ' + repr(self.port) + ' ' +\
 6471            'port_override: ' + repr(self.port_override) + ' ' +\
 6472            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6473            'tags: ' + repr(self.tags) + ' ' +\
 6474            'token: ' + repr(self.token) + ' ' +\
 6475            '>'
 6476
 6477    def to_dict(self):
 6478        return {
 6479            'bind_interface': self.bind_interface,
 6480            'egress_filter': self.egress_filter,
 6481            'healthcheck_namespace': self.healthcheck_namespace,
 6482            'healthy': self.healthy,
 6483            'hostname': self.hostname,
 6484            'id': self.id,
 6485            'name': self.name,
 6486            'port': self.port,
 6487            'port_override': self.port_override,
 6488            'secret_store_id': self.secret_store_id,
 6489            'tags': self.tags,
 6490            'token': self.token,
 6491        }
 6492
 6493    @classmethod
 6494    def from_dict(cls, d):
 6495        return cls(
 6496            bind_interface=d.get('bind_interface'),
 6497            egress_filter=d.get('egress_filter'),
 6498            healthcheck_namespace=d.get('healthcheck_namespace'),
 6499            healthy=d.get('healthy'),
 6500            hostname=d.get('hostname'),
 6501            id=d.get('id'),
 6502            name=d.get('name'),
 6503            port=d.get('port'),
 6504            port_override=d.get('port_override'),
 6505            secret_store_id=d.get('secret_store_id'),
 6506            tags=d.get('tags'),
 6507            token=d.get('token'),
 6508        )
 6509
 6510
 6511class KubernetesUserImpersonation:
 6512    __slots__ = [
 6513        'bind_interface',
 6514        'certificate_authority',
 6515        'client_certificate',
 6516        'client_key',
 6517        'egress_filter',
 6518        'healthcheck_namespace',
 6519        'healthy',
 6520        'hostname',
 6521        'id',
 6522        'name',
 6523        'port',
 6524        'port_override',
 6525        'secret_store_id',
 6526        'tags',
 6527    ]
 6528
 6529    def __init__(
 6530        self,
 6531        bind_interface=None,
 6532        certificate_authority=None,
 6533        client_certificate=None,
 6534        client_key=None,
 6535        egress_filter=None,
 6536        healthcheck_namespace=None,
 6537        healthy=None,
 6538        hostname=None,
 6539        id=None,
 6540        name=None,
 6541        port=None,
 6542        port_override=None,
 6543        secret_store_id=None,
 6544        tags=None,
 6545    ):
 6546        self.bind_interface = bind_interface if bind_interface is not None else ''
 6547        '''
 6548         Bind interface
 6549        '''
 6550        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6551        self.client_certificate = client_certificate if client_certificate is not None else ''
 6552        self.client_key = client_key if client_key is not None else ''
 6553        self.egress_filter = egress_filter if egress_filter is not None else ''
 6554        '''
 6555         A filter applied to the routing logic to pin datasource to nodes.
 6556        '''
 6557        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6558        '''
 6559         The path used to check the health of your connection.  Defaults to `default`.
 6560        '''
 6561        self.healthy = healthy if healthy is not None else False
 6562        '''
 6563         True if the datasource is reachable and the credentials are valid.
 6564        '''
 6565        self.hostname = hostname if hostname is not None else ''
 6566        self.id = id if id is not None else ''
 6567        '''
 6568         Unique identifier of the Resource.
 6569        '''
 6570        self.name = name if name is not None else ''
 6571        '''
 6572         Unique human-readable name of the Resource.
 6573        '''
 6574        self.port = port if port is not None else 0
 6575        self.port_override = port_override if port_override is not None else 0
 6576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6577        '''
 6578         ID of the secret store containing credentials for this resource, if any.
 6579        '''
 6580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6581        '''
 6582         Tags is a map of key, value pairs.
 6583        '''
 6584
 6585    def __repr__(self):
 6586        return '<sdm.KubernetesUserImpersonation ' + \
 6587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6588            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6589            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6590            'client_key: ' + repr(self.client_key) + ' ' +\
 6591            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6592            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6593            'healthy: ' + repr(self.healthy) + ' ' +\
 6594            'hostname: ' + repr(self.hostname) + ' ' +\
 6595            'id: ' + repr(self.id) + ' ' +\
 6596            'name: ' + repr(self.name) + ' ' +\
 6597            'port: ' + repr(self.port) + ' ' +\
 6598            'port_override: ' + repr(self.port_override) + ' ' +\
 6599            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6600            'tags: ' + repr(self.tags) + ' ' +\
 6601            '>'
 6602
 6603    def to_dict(self):
 6604        return {
 6605            'bind_interface': self.bind_interface,
 6606            'certificate_authority': self.certificate_authority,
 6607            'client_certificate': self.client_certificate,
 6608            'client_key': self.client_key,
 6609            'egress_filter': self.egress_filter,
 6610            'healthcheck_namespace': self.healthcheck_namespace,
 6611            'healthy': self.healthy,
 6612            'hostname': self.hostname,
 6613            'id': self.id,
 6614            'name': self.name,
 6615            'port': self.port,
 6616            'port_override': self.port_override,
 6617            'secret_store_id': self.secret_store_id,
 6618            'tags': self.tags,
 6619        }
 6620
 6621    @classmethod
 6622    def from_dict(cls, d):
 6623        return cls(
 6624            bind_interface=d.get('bind_interface'),
 6625            certificate_authority=d.get('certificate_authority'),
 6626            client_certificate=d.get('client_certificate'),
 6627            client_key=d.get('client_key'),
 6628            egress_filter=d.get('egress_filter'),
 6629            healthcheck_namespace=d.get('healthcheck_namespace'),
 6630            healthy=d.get('healthy'),
 6631            hostname=d.get('hostname'),
 6632            id=d.get('id'),
 6633            name=d.get('name'),
 6634            port=d.get('port'),
 6635            port_override=d.get('port_override'),
 6636            secret_store_id=d.get('secret_store_id'),
 6637            tags=d.get('tags'),
 6638        )
 6639
 6640
 6641class MTLSMysql:
 6642    '''
 6643    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6644    without a major version bump.
 6645    '''
 6646    __slots__ = [
 6647        'bind_interface',
 6648        'certificate_authority',
 6649        'client_certificate',
 6650        'client_key',
 6651        'database',
 6652        'egress_filter',
 6653        'healthy',
 6654        'hostname',
 6655        'id',
 6656        'name',
 6657        'password',
 6658        'port',
 6659        'port_override',
 6660        'secret_store_id',
 6661        'server_name',
 6662        'tags',
 6663        'username',
 6664    ]
 6665
 6666    def __init__(
 6667        self,
 6668        bind_interface=None,
 6669        certificate_authority=None,
 6670        client_certificate=None,
 6671        client_key=None,
 6672        database=None,
 6673        egress_filter=None,
 6674        healthy=None,
 6675        hostname=None,
 6676        id=None,
 6677        name=None,
 6678        password=None,
 6679        port=None,
 6680        port_override=None,
 6681        secret_store_id=None,
 6682        server_name=None,
 6683        tags=None,
 6684        username=None,
 6685    ):
 6686        self.bind_interface = bind_interface if bind_interface is not None else ''
 6687        '''
 6688         Bind interface
 6689        '''
 6690        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6691        self.client_certificate = client_certificate if client_certificate is not None else ''
 6692        self.client_key = client_key if client_key is not None else ''
 6693        self.database = database if database is not None else ''
 6694        self.egress_filter = egress_filter if egress_filter is not None else ''
 6695        '''
 6696         A filter applied to the routing logic to pin datasource to nodes.
 6697        '''
 6698        self.healthy = healthy if healthy is not None else False
 6699        '''
 6700         True if the datasource is reachable and the credentials are valid.
 6701        '''
 6702        self.hostname = hostname if hostname is not None else ''
 6703        self.id = id if id is not None else ''
 6704        '''
 6705         Unique identifier of the Resource.
 6706        '''
 6707        self.name = name if name is not None else ''
 6708        '''
 6709         Unique human-readable name of the Resource.
 6710        '''
 6711        self.password = password if password is not None else ''
 6712        self.port = port if port is not None else 0
 6713        self.port_override = port_override if port_override is not None else 0
 6714        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6715        '''
 6716         ID of the secret store containing credentials for this resource, if any.
 6717        '''
 6718        self.server_name = server_name if server_name is not None else ''
 6719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6720        '''
 6721         Tags is a map of key, value pairs.
 6722        '''
 6723        self.username = username if username is not None else ''
 6724
 6725    def __repr__(self):
 6726        return '<sdm.MTLSMysql ' + \
 6727            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6728            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6729            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6730            'client_key: ' + repr(self.client_key) + ' ' +\
 6731            'database: ' + repr(self.database) + ' ' +\
 6732            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6733            'healthy: ' + repr(self.healthy) + ' ' +\
 6734            'hostname: ' + repr(self.hostname) + ' ' +\
 6735            'id: ' + repr(self.id) + ' ' +\
 6736            'name: ' + repr(self.name) + ' ' +\
 6737            'password: ' + repr(self.password) + ' ' +\
 6738            'port: ' + repr(self.port) + ' ' +\
 6739            'port_override: ' + repr(self.port_override) + ' ' +\
 6740            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6741            'server_name: ' + repr(self.server_name) + ' ' +\
 6742            'tags: ' + repr(self.tags) + ' ' +\
 6743            'username: ' + repr(self.username) + ' ' +\
 6744            '>'
 6745
 6746    def to_dict(self):
 6747        return {
 6748            'bind_interface': self.bind_interface,
 6749            'certificate_authority': self.certificate_authority,
 6750            'client_certificate': self.client_certificate,
 6751            'client_key': self.client_key,
 6752            'database': self.database,
 6753            'egress_filter': self.egress_filter,
 6754            'healthy': self.healthy,
 6755            'hostname': self.hostname,
 6756            'id': self.id,
 6757            'name': self.name,
 6758            'password': self.password,
 6759            'port': self.port,
 6760            'port_override': self.port_override,
 6761            'secret_store_id': self.secret_store_id,
 6762            'server_name': self.server_name,
 6763            'tags': self.tags,
 6764            'username': self.username,
 6765        }
 6766
 6767    @classmethod
 6768    def from_dict(cls, d):
 6769        return cls(
 6770            bind_interface=d.get('bind_interface'),
 6771            certificate_authority=d.get('certificate_authority'),
 6772            client_certificate=d.get('client_certificate'),
 6773            client_key=d.get('client_key'),
 6774            database=d.get('database'),
 6775            egress_filter=d.get('egress_filter'),
 6776            healthy=d.get('healthy'),
 6777            hostname=d.get('hostname'),
 6778            id=d.get('id'),
 6779            name=d.get('name'),
 6780            password=d.get('password'),
 6781            port=d.get('port'),
 6782            port_override=d.get('port_override'),
 6783            secret_store_id=d.get('secret_store_id'),
 6784            server_name=d.get('server_name'),
 6785            tags=d.get('tags'),
 6786            username=d.get('username'),
 6787        )
 6788
 6789
 6790class MTLSPostgres:
 6791    __slots__ = [
 6792        'bind_interface',
 6793        'certificate_authority',
 6794        'client_certificate',
 6795        'client_key',
 6796        'database',
 6797        'egress_filter',
 6798        'healthy',
 6799        'hostname',
 6800        'id',
 6801        'name',
 6802        'override_database',
 6803        'password',
 6804        'port',
 6805        'port_override',
 6806        'secret_store_id',
 6807        'server_name',
 6808        'tags',
 6809        'username',
 6810    ]
 6811
 6812    def __init__(
 6813        self,
 6814        bind_interface=None,
 6815        certificate_authority=None,
 6816        client_certificate=None,
 6817        client_key=None,
 6818        database=None,
 6819        egress_filter=None,
 6820        healthy=None,
 6821        hostname=None,
 6822        id=None,
 6823        name=None,
 6824        override_database=None,
 6825        password=None,
 6826        port=None,
 6827        port_override=None,
 6828        secret_store_id=None,
 6829        server_name=None,
 6830        tags=None,
 6831        username=None,
 6832    ):
 6833        self.bind_interface = bind_interface if bind_interface is not None else ''
 6834        '''
 6835         Bind interface
 6836        '''
 6837        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6838        self.client_certificate = client_certificate if client_certificate is not None else ''
 6839        self.client_key = client_key if client_key is not None else ''
 6840        self.database = database if database is not None else ''
 6841        self.egress_filter = egress_filter if egress_filter is not None else ''
 6842        '''
 6843         A filter applied to the routing logic to pin datasource to nodes.
 6844        '''
 6845        self.healthy = healthy if healthy is not None else False
 6846        '''
 6847         True if the datasource is reachable and the credentials are valid.
 6848        '''
 6849        self.hostname = hostname if hostname is not None else ''
 6850        self.id = id if id is not None else ''
 6851        '''
 6852         Unique identifier of the Resource.
 6853        '''
 6854        self.name = name if name is not None else ''
 6855        '''
 6856         Unique human-readable name of the Resource.
 6857        '''
 6858        self.override_database = override_database if override_database is not None else False
 6859        self.password = password if password is not None else ''
 6860        self.port = port if port is not None else 0
 6861        self.port_override = port_override if port_override is not None else 0
 6862        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6863        '''
 6864         ID of the secret store containing credentials for this resource, if any.
 6865        '''
 6866        self.server_name = server_name if server_name is not None else ''
 6867        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6868        '''
 6869         Tags is a map of key, value pairs.
 6870        '''
 6871        self.username = username if username is not None else ''
 6872
 6873    def __repr__(self):
 6874        return '<sdm.MTLSPostgres ' + \
 6875            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6876            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6877            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6878            'client_key: ' + repr(self.client_key) + ' ' +\
 6879            'database: ' + repr(self.database) + ' ' +\
 6880            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6881            'healthy: ' + repr(self.healthy) + ' ' +\
 6882            'hostname: ' + repr(self.hostname) + ' ' +\
 6883            'id: ' + repr(self.id) + ' ' +\
 6884            'name: ' + repr(self.name) + ' ' +\
 6885            'override_database: ' + repr(self.override_database) + ' ' +\
 6886            'password: ' + repr(self.password) + ' ' +\
 6887            'port: ' + repr(self.port) + ' ' +\
 6888            'port_override: ' + repr(self.port_override) + ' ' +\
 6889            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6890            'server_name: ' + repr(self.server_name) + ' ' +\
 6891            'tags: ' + repr(self.tags) + ' ' +\
 6892            'username: ' + repr(self.username) + ' ' +\
 6893            '>'
 6894
 6895    def to_dict(self):
 6896        return {
 6897            'bind_interface': self.bind_interface,
 6898            'certificate_authority': self.certificate_authority,
 6899            'client_certificate': self.client_certificate,
 6900            'client_key': self.client_key,
 6901            'database': self.database,
 6902            'egress_filter': self.egress_filter,
 6903            'healthy': self.healthy,
 6904            'hostname': self.hostname,
 6905            'id': self.id,
 6906            'name': self.name,
 6907            'override_database': self.override_database,
 6908            'password': self.password,
 6909            'port': self.port,
 6910            'port_override': self.port_override,
 6911            'secret_store_id': self.secret_store_id,
 6912            'server_name': self.server_name,
 6913            'tags': self.tags,
 6914            'username': self.username,
 6915        }
 6916
 6917    @classmethod
 6918    def from_dict(cls, d):
 6919        return cls(
 6920            bind_interface=d.get('bind_interface'),
 6921            certificate_authority=d.get('certificate_authority'),
 6922            client_certificate=d.get('client_certificate'),
 6923            client_key=d.get('client_key'),
 6924            database=d.get('database'),
 6925            egress_filter=d.get('egress_filter'),
 6926            healthy=d.get('healthy'),
 6927            hostname=d.get('hostname'),
 6928            id=d.get('id'),
 6929            name=d.get('name'),
 6930            override_database=d.get('override_database'),
 6931            password=d.get('password'),
 6932            port=d.get('port'),
 6933            port_override=d.get('port_override'),
 6934            secret_store_id=d.get('secret_store_id'),
 6935            server_name=d.get('server_name'),
 6936            tags=d.get('tags'),
 6937            username=d.get('username'),
 6938        )
 6939
 6940
 6941class Maria:
 6942    __slots__ = [
 6943        'bind_interface',
 6944        'database',
 6945        'egress_filter',
 6946        'healthy',
 6947        'hostname',
 6948        'id',
 6949        'name',
 6950        'password',
 6951        'port',
 6952        'port_override',
 6953        'secret_store_id',
 6954        'tags',
 6955        'username',
 6956    ]
 6957
 6958    def __init__(
 6959        self,
 6960        bind_interface=None,
 6961        database=None,
 6962        egress_filter=None,
 6963        healthy=None,
 6964        hostname=None,
 6965        id=None,
 6966        name=None,
 6967        password=None,
 6968        port=None,
 6969        port_override=None,
 6970        secret_store_id=None,
 6971        tags=None,
 6972        username=None,
 6973    ):
 6974        self.bind_interface = bind_interface if bind_interface is not None else ''
 6975        '''
 6976         Bind interface
 6977        '''
 6978        self.database = database if database is not None else ''
 6979        self.egress_filter = egress_filter if egress_filter is not None else ''
 6980        '''
 6981         A filter applied to the routing logic to pin datasource to nodes.
 6982        '''
 6983        self.healthy = healthy if healthy is not None else False
 6984        '''
 6985         True if the datasource is reachable and the credentials are valid.
 6986        '''
 6987        self.hostname = hostname if hostname is not None else ''
 6988        self.id = id if id is not None else ''
 6989        '''
 6990         Unique identifier of the Resource.
 6991        '''
 6992        self.name = name if name is not None else ''
 6993        '''
 6994         Unique human-readable name of the Resource.
 6995        '''
 6996        self.password = password if password is not None else ''
 6997        self.port = port if port is not None else 0
 6998        self.port_override = port_override if port_override is not None else 0
 6999        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7000        '''
 7001         ID of the secret store containing credentials for this resource, if any.
 7002        '''
 7003        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7004        '''
 7005         Tags is a map of key, value pairs.
 7006        '''
 7007        self.username = username if username is not None else ''
 7008
 7009    def __repr__(self):
 7010        return '<sdm.Maria ' + \
 7011            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7012            'database: ' + repr(self.database) + ' ' +\
 7013            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7014            'healthy: ' + repr(self.healthy) + ' ' +\
 7015            'hostname: ' + repr(self.hostname) + ' ' +\
 7016            'id: ' + repr(self.id) + ' ' +\
 7017            'name: ' + repr(self.name) + ' ' +\
 7018            'password: ' + repr(self.password) + ' ' +\
 7019            'port: ' + repr(self.port) + ' ' +\
 7020            'port_override: ' + repr(self.port_override) + ' ' +\
 7021            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7022            'tags: ' + repr(self.tags) + ' ' +\
 7023            'username: ' + repr(self.username) + ' ' +\
 7024            '>'
 7025
 7026    def to_dict(self):
 7027        return {
 7028            'bind_interface': self.bind_interface,
 7029            'database': self.database,
 7030            'egress_filter': self.egress_filter,
 7031            'healthy': self.healthy,
 7032            'hostname': self.hostname,
 7033            'id': self.id,
 7034            'name': self.name,
 7035            'password': self.password,
 7036            'port': self.port,
 7037            'port_override': self.port_override,
 7038            'secret_store_id': self.secret_store_id,
 7039            'tags': self.tags,
 7040            'username': self.username,
 7041        }
 7042
 7043    @classmethod
 7044    def from_dict(cls, d):
 7045        return cls(
 7046            bind_interface=d.get('bind_interface'),
 7047            database=d.get('database'),
 7048            egress_filter=d.get('egress_filter'),
 7049            healthy=d.get('healthy'),
 7050            hostname=d.get('hostname'),
 7051            id=d.get('id'),
 7052            name=d.get('name'),
 7053            password=d.get('password'),
 7054            port=d.get('port'),
 7055            port_override=d.get('port_override'),
 7056            secret_store_id=d.get('secret_store_id'),
 7057            tags=d.get('tags'),
 7058            username=d.get('username'),
 7059        )
 7060
 7061
 7062class Memcached:
 7063    __slots__ = [
 7064        'bind_interface',
 7065        'egress_filter',
 7066        'healthy',
 7067        'hostname',
 7068        'id',
 7069        'name',
 7070        'port',
 7071        'port_override',
 7072        'secret_store_id',
 7073        'tags',
 7074    ]
 7075
 7076    def __init__(
 7077        self,
 7078        bind_interface=None,
 7079        egress_filter=None,
 7080        healthy=None,
 7081        hostname=None,
 7082        id=None,
 7083        name=None,
 7084        port=None,
 7085        port_override=None,
 7086        secret_store_id=None,
 7087        tags=None,
 7088    ):
 7089        self.bind_interface = bind_interface if bind_interface is not None else ''
 7090        '''
 7091         Bind interface
 7092        '''
 7093        self.egress_filter = egress_filter if egress_filter is not None else ''
 7094        '''
 7095         A filter applied to the routing logic to pin datasource to nodes.
 7096        '''
 7097        self.healthy = healthy if healthy is not None else False
 7098        '''
 7099         True if the datasource is reachable and the credentials are valid.
 7100        '''
 7101        self.hostname = hostname if hostname is not None else ''
 7102        self.id = id if id is not None else ''
 7103        '''
 7104         Unique identifier of the Resource.
 7105        '''
 7106        self.name = name if name is not None else ''
 7107        '''
 7108         Unique human-readable name of the Resource.
 7109        '''
 7110        self.port = port if port is not None else 0
 7111        self.port_override = port_override if port_override is not None else 0
 7112        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7113        '''
 7114         ID of the secret store containing credentials for this resource, if any.
 7115        '''
 7116        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7117        '''
 7118         Tags is a map of key, value pairs.
 7119        '''
 7120
 7121    def __repr__(self):
 7122        return '<sdm.Memcached ' + \
 7123            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7124            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7125            'healthy: ' + repr(self.healthy) + ' ' +\
 7126            'hostname: ' + repr(self.hostname) + ' ' +\
 7127            'id: ' + repr(self.id) + ' ' +\
 7128            'name: ' + repr(self.name) + ' ' +\
 7129            'port: ' + repr(self.port) + ' ' +\
 7130            'port_override: ' + repr(self.port_override) + ' ' +\
 7131            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7132            'tags: ' + repr(self.tags) + ' ' +\
 7133            '>'
 7134
 7135    def to_dict(self):
 7136        return {
 7137            'bind_interface': self.bind_interface,
 7138            'egress_filter': self.egress_filter,
 7139            'healthy': self.healthy,
 7140            'hostname': self.hostname,
 7141            'id': self.id,
 7142            'name': self.name,
 7143            'port': self.port,
 7144            'port_override': self.port_override,
 7145            'secret_store_id': self.secret_store_id,
 7146            'tags': self.tags,
 7147        }
 7148
 7149    @classmethod
 7150    def from_dict(cls, d):
 7151        return cls(
 7152            bind_interface=d.get('bind_interface'),
 7153            egress_filter=d.get('egress_filter'),
 7154            healthy=d.get('healthy'),
 7155            hostname=d.get('hostname'),
 7156            id=d.get('id'),
 7157            name=d.get('name'),
 7158            port=d.get('port'),
 7159            port_override=d.get('port_override'),
 7160            secret_store_id=d.get('secret_store_id'),
 7161            tags=d.get('tags'),
 7162        )
 7163
 7164
 7165class Memsql:
 7166    __slots__ = [
 7167        'bind_interface',
 7168        'database',
 7169        'egress_filter',
 7170        'healthy',
 7171        'hostname',
 7172        'id',
 7173        'name',
 7174        'password',
 7175        'port',
 7176        'port_override',
 7177        'secret_store_id',
 7178        'tags',
 7179        'username',
 7180    ]
 7181
 7182    def __init__(
 7183        self,
 7184        bind_interface=None,
 7185        database=None,
 7186        egress_filter=None,
 7187        healthy=None,
 7188        hostname=None,
 7189        id=None,
 7190        name=None,
 7191        password=None,
 7192        port=None,
 7193        port_override=None,
 7194        secret_store_id=None,
 7195        tags=None,
 7196        username=None,
 7197    ):
 7198        self.bind_interface = bind_interface if bind_interface is not None else ''
 7199        '''
 7200         Bind interface
 7201        '''
 7202        self.database = database if database is not None else ''
 7203        self.egress_filter = egress_filter if egress_filter is not None else ''
 7204        '''
 7205         A filter applied to the routing logic to pin datasource to nodes.
 7206        '''
 7207        self.healthy = healthy if healthy is not None else False
 7208        '''
 7209         True if the datasource is reachable and the credentials are valid.
 7210        '''
 7211        self.hostname = hostname if hostname is not None else ''
 7212        self.id = id if id is not None else ''
 7213        '''
 7214         Unique identifier of the Resource.
 7215        '''
 7216        self.name = name if name is not None else ''
 7217        '''
 7218         Unique human-readable name of the Resource.
 7219        '''
 7220        self.password = password if password is not None else ''
 7221        self.port = port if port is not None else 0
 7222        self.port_override = port_override if port_override is not None else 0
 7223        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7224        '''
 7225         ID of the secret store containing credentials for this resource, if any.
 7226        '''
 7227        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7228        '''
 7229         Tags is a map of key, value pairs.
 7230        '''
 7231        self.username = username if username is not None else ''
 7232
 7233    def __repr__(self):
 7234        return '<sdm.Memsql ' + \
 7235            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7236            'database: ' + repr(self.database) + ' ' +\
 7237            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7238            'healthy: ' + repr(self.healthy) + ' ' +\
 7239            'hostname: ' + repr(self.hostname) + ' ' +\
 7240            'id: ' + repr(self.id) + ' ' +\
 7241            'name: ' + repr(self.name) + ' ' +\
 7242            'password: ' + repr(self.password) + ' ' +\
 7243            'port: ' + repr(self.port) + ' ' +\
 7244            'port_override: ' + repr(self.port_override) + ' ' +\
 7245            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7246            'tags: ' + repr(self.tags) + ' ' +\
 7247            'username: ' + repr(self.username) + ' ' +\
 7248            '>'
 7249
 7250    def to_dict(self):
 7251        return {
 7252            'bind_interface': self.bind_interface,
 7253            'database': self.database,
 7254            'egress_filter': self.egress_filter,
 7255            'healthy': self.healthy,
 7256            'hostname': self.hostname,
 7257            'id': self.id,
 7258            'name': self.name,
 7259            'password': self.password,
 7260            'port': self.port,
 7261            'port_override': self.port_override,
 7262            'secret_store_id': self.secret_store_id,
 7263            'tags': self.tags,
 7264            'username': self.username,
 7265        }
 7266
 7267    @classmethod
 7268    def from_dict(cls, d):
 7269        return cls(
 7270            bind_interface=d.get('bind_interface'),
 7271            database=d.get('database'),
 7272            egress_filter=d.get('egress_filter'),
 7273            healthy=d.get('healthy'),
 7274            hostname=d.get('hostname'),
 7275            id=d.get('id'),
 7276            name=d.get('name'),
 7277            password=d.get('password'),
 7278            port=d.get('port'),
 7279            port_override=d.get('port_override'),
 7280            secret_store_id=d.get('secret_store_id'),
 7281            tags=d.get('tags'),
 7282            username=d.get('username'),
 7283        )
 7284
 7285
 7286class MongoHost:
 7287    '''
 7288    MongoHost is currently unstable, and its API may change, or it may be removed,
 7289    without a major version bump.
 7290    '''
 7291    __slots__ = [
 7292        'auth_database',
 7293        'bind_interface',
 7294        'egress_filter',
 7295        'healthy',
 7296        'hostname',
 7297        'id',
 7298        'name',
 7299        'password',
 7300        'port',
 7301        'port_override',
 7302        'secret_store_id',
 7303        'tags',
 7304        'tls_required',
 7305        'username',
 7306    ]
 7307
 7308    def __init__(
 7309        self,
 7310        auth_database=None,
 7311        bind_interface=None,
 7312        egress_filter=None,
 7313        healthy=None,
 7314        hostname=None,
 7315        id=None,
 7316        name=None,
 7317        password=None,
 7318        port=None,
 7319        port_override=None,
 7320        secret_store_id=None,
 7321        tags=None,
 7322        tls_required=None,
 7323        username=None,
 7324    ):
 7325        self.auth_database = auth_database if auth_database is not None else ''
 7326        self.bind_interface = bind_interface if bind_interface is not None else ''
 7327        '''
 7328         Bind interface
 7329        '''
 7330        self.egress_filter = egress_filter if egress_filter is not None else ''
 7331        '''
 7332         A filter applied to the routing logic to pin datasource to nodes.
 7333        '''
 7334        self.healthy = healthy if healthy is not None else False
 7335        '''
 7336         True if the datasource is reachable and the credentials are valid.
 7337        '''
 7338        self.hostname = hostname if hostname is not None else ''
 7339        self.id = id if id is not None else ''
 7340        '''
 7341         Unique identifier of the Resource.
 7342        '''
 7343        self.name = name if name is not None else ''
 7344        '''
 7345         Unique human-readable name of the Resource.
 7346        '''
 7347        self.password = password if password is not None else ''
 7348        self.port = port if port is not None else 0
 7349        self.port_override = port_override if port_override is not None else 0
 7350        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7351        '''
 7352         ID of the secret store containing credentials for this resource, if any.
 7353        '''
 7354        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7355        '''
 7356         Tags is a map of key, value pairs.
 7357        '''
 7358        self.tls_required = tls_required if tls_required is not None else False
 7359        self.username = username if username is not None else ''
 7360
 7361    def __repr__(self):
 7362        return '<sdm.MongoHost ' + \
 7363            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7364            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7365            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7366            'healthy: ' + repr(self.healthy) + ' ' +\
 7367            'hostname: ' + repr(self.hostname) + ' ' +\
 7368            'id: ' + repr(self.id) + ' ' +\
 7369            'name: ' + repr(self.name) + ' ' +\
 7370            'password: ' + repr(self.password) + ' ' +\
 7371            'port: ' + repr(self.port) + ' ' +\
 7372            'port_override: ' + repr(self.port_override) + ' ' +\
 7373            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7374            'tags: ' + repr(self.tags) + ' ' +\
 7375            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7376            'username: ' + repr(self.username) + ' ' +\
 7377            '>'
 7378
 7379    def to_dict(self):
 7380        return {
 7381            'auth_database': self.auth_database,
 7382            'bind_interface': self.bind_interface,
 7383            'egress_filter': self.egress_filter,
 7384            'healthy': self.healthy,
 7385            'hostname': self.hostname,
 7386            'id': self.id,
 7387            'name': self.name,
 7388            'password': self.password,
 7389            'port': self.port,
 7390            'port_override': self.port_override,
 7391            'secret_store_id': self.secret_store_id,
 7392            'tags': self.tags,
 7393            'tls_required': self.tls_required,
 7394            'username': self.username,
 7395        }
 7396
 7397    @classmethod
 7398    def from_dict(cls, d):
 7399        return cls(
 7400            auth_database=d.get('auth_database'),
 7401            bind_interface=d.get('bind_interface'),
 7402            egress_filter=d.get('egress_filter'),
 7403            healthy=d.get('healthy'),
 7404            hostname=d.get('hostname'),
 7405            id=d.get('id'),
 7406            name=d.get('name'),
 7407            password=d.get('password'),
 7408            port=d.get('port'),
 7409            port_override=d.get('port_override'),
 7410            secret_store_id=d.get('secret_store_id'),
 7411            tags=d.get('tags'),
 7412            tls_required=d.get('tls_required'),
 7413            username=d.get('username'),
 7414        )
 7415
 7416
 7417class MongoLegacyHost:
 7418    __slots__ = [
 7419        'auth_database',
 7420        'bind_interface',
 7421        'egress_filter',
 7422        'healthy',
 7423        'hostname',
 7424        'id',
 7425        'name',
 7426        'password',
 7427        'port',
 7428        'port_override',
 7429        'replica_set',
 7430        'secret_store_id',
 7431        'tags',
 7432        'tls_required',
 7433        'username',
 7434    ]
 7435
 7436    def __init__(
 7437        self,
 7438        auth_database=None,
 7439        bind_interface=None,
 7440        egress_filter=None,
 7441        healthy=None,
 7442        hostname=None,
 7443        id=None,
 7444        name=None,
 7445        password=None,
 7446        port=None,
 7447        port_override=None,
 7448        replica_set=None,
 7449        secret_store_id=None,
 7450        tags=None,
 7451        tls_required=None,
 7452        username=None,
 7453    ):
 7454        self.auth_database = auth_database if auth_database is not None else ''
 7455        self.bind_interface = bind_interface if bind_interface is not None else ''
 7456        '''
 7457         Bind interface
 7458        '''
 7459        self.egress_filter = egress_filter if egress_filter is not None else ''
 7460        '''
 7461         A filter applied to the routing logic to pin datasource to nodes.
 7462        '''
 7463        self.healthy = healthy if healthy is not None else False
 7464        '''
 7465         True if the datasource is reachable and the credentials are valid.
 7466        '''
 7467        self.hostname = hostname if hostname is not None else ''
 7468        self.id = id if id is not None else ''
 7469        '''
 7470         Unique identifier of the Resource.
 7471        '''
 7472        self.name = name if name is not None else ''
 7473        '''
 7474         Unique human-readable name of the Resource.
 7475        '''
 7476        self.password = password if password is not None else ''
 7477        self.port = port if port is not None else 0
 7478        self.port_override = port_override if port_override is not None else 0
 7479        self.replica_set = replica_set if replica_set is not None else ''
 7480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7481        '''
 7482         ID of the secret store containing credentials for this resource, if any.
 7483        '''
 7484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7485        '''
 7486         Tags is a map of key, value pairs.
 7487        '''
 7488        self.tls_required = tls_required if tls_required is not None else False
 7489        self.username = username if username is not None else ''
 7490
 7491    def __repr__(self):
 7492        return '<sdm.MongoLegacyHost ' + \
 7493            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7494            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7495            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7496            'healthy: ' + repr(self.healthy) + ' ' +\
 7497            'hostname: ' + repr(self.hostname) + ' ' +\
 7498            'id: ' + repr(self.id) + ' ' +\
 7499            'name: ' + repr(self.name) + ' ' +\
 7500            'password: ' + repr(self.password) + ' ' +\
 7501            'port: ' + repr(self.port) + ' ' +\
 7502            'port_override: ' + repr(self.port_override) + ' ' +\
 7503            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7504            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7505            'tags: ' + repr(self.tags) + ' ' +\
 7506            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7507            'username: ' + repr(self.username) + ' ' +\
 7508            '>'
 7509
 7510    def to_dict(self):
 7511        return {
 7512            'auth_database': self.auth_database,
 7513            'bind_interface': self.bind_interface,
 7514            'egress_filter': self.egress_filter,
 7515            'healthy': self.healthy,
 7516            'hostname': self.hostname,
 7517            'id': self.id,
 7518            'name': self.name,
 7519            'password': self.password,
 7520            'port': self.port,
 7521            'port_override': self.port_override,
 7522            'replica_set': self.replica_set,
 7523            'secret_store_id': self.secret_store_id,
 7524            'tags': self.tags,
 7525            'tls_required': self.tls_required,
 7526            'username': self.username,
 7527        }
 7528
 7529    @classmethod
 7530    def from_dict(cls, d):
 7531        return cls(
 7532            auth_database=d.get('auth_database'),
 7533            bind_interface=d.get('bind_interface'),
 7534            egress_filter=d.get('egress_filter'),
 7535            healthy=d.get('healthy'),
 7536            hostname=d.get('hostname'),
 7537            id=d.get('id'),
 7538            name=d.get('name'),
 7539            password=d.get('password'),
 7540            port=d.get('port'),
 7541            port_override=d.get('port_override'),
 7542            replica_set=d.get('replica_set'),
 7543            secret_store_id=d.get('secret_store_id'),
 7544            tags=d.get('tags'),
 7545            tls_required=d.get('tls_required'),
 7546            username=d.get('username'),
 7547        )
 7548
 7549
 7550class MongoLegacyReplicaset:
 7551    __slots__ = [
 7552        'auth_database',
 7553        'bind_interface',
 7554        'connect_to_replica',
 7555        'egress_filter',
 7556        'healthy',
 7557        'hostname',
 7558        'id',
 7559        'name',
 7560        'password',
 7561        'port',
 7562        'port_override',
 7563        'replica_set',
 7564        'secret_store_id',
 7565        'tags',
 7566        'tls_required',
 7567        'username',
 7568    ]
 7569
 7570    def __init__(
 7571        self,
 7572        auth_database=None,
 7573        bind_interface=None,
 7574        connect_to_replica=None,
 7575        egress_filter=None,
 7576        healthy=None,
 7577        hostname=None,
 7578        id=None,
 7579        name=None,
 7580        password=None,
 7581        port=None,
 7582        port_override=None,
 7583        replica_set=None,
 7584        secret_store_id=None,
 7585        tags=None,
 7586        tls_required=None,
 7587        username=None,
 7588    ):
 7589        self.auth_database = auth_database if auth_database is not None else ''
 7590        self.bind_interface = bind_interface if bind_interface is not None else ''
 7591        '''
 7592         Bind interface
 7593        '''
 7594        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7595        self.egress_filter = egress_filter if egress_filter is not None else ''
 7596        '''
 7597         A filter applied to the routing logic to pin datasource to nodes.
 7598        '''
 7599        self.healthy = healthy if healthy is not None else False
 7600        '''
 7601         True if the datasource is reachable and the credentials are valid.
 7602        '''
 7603        self.hostname = hostname if hostname is not None else ''
 7604        self.id = id if id is not None else ''
 7605        '''
 7606         Unique identifier of the Resource.
 7607        '''
 7608        self.name = name if name is not None else ''
 7609        '''
 7610         Unique human-readable name of the Resource.
 7611        '''
 7612        self.password = password if password is not None else ''
 7613        self.port = port if port is not None else 0
 7614        self.port_override = port_override if port_override is not None else 0
 7615        self.replica_set = replica_set if replica_set is not None else ''
 7616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7617        '''
 7618         ID of the secret store containing credentials for this resource, if any.
 7619        '''
 7620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7621        '''
 7622         Tags is a map of key, value pairs.
 7623        '''
 7624        self.tls_required = tls_required if tls_required is not None else False
 7625        self.username = username if username is not None else ''
 7626
 7627    def __repr__(self):
 7628        return '<sdm.MongoLegacyReplicaset ' + \
 7629            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7630            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7631            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7632            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7633            'healthy: ' + repr(self.healthy) + ' ' +\
 7634            'hostname: ' + repr(self.hostname) + ' ' +\
 7635            'id: ' + repr(self.id) + ' ' +\
 7636            'name: ' + repr(self.name) + ' ' +\
 7637            'password: ' + repr(self.password) + ' ' +\
 7638            'port: ' + repr(self.port) + ' ' +\
 7639            'port_override: ' + repr(self.port_override) + ' ' +\
 7640            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7641            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7642            'tags: ' + repr(self.tags) + ' ' +\
 7643            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7644            'username: ' + repr(self.username) + ' ' +\
 7645            '>'
 7646
 7647    def to_dict(self):
 7648        return {
 7649            'auth_database': self.auth_database,
 7650            'bind_interface': self.bind_interface,
 7651            'connect_to_replica': self.connect_to_replica,
 7652            'egress_filter': self.egress_filter,
 7653            'healthy': self.healthy,
 7654            'hostname': self.hostname,
 7655            'id': self.id,
 7656            'name': self.name,
 7657            'password': self.password,
 7658            'port': self.port,
 7659            'port_override': self.port_override,
 7660            'replica_set': self.replica_set,
 7661            'secret_store_id': self.secret_store_id,
 7662            'tags': self.tags,
 7663            'tls_required': self.tls_required,
 7664            'username': self.username,
 7665        }
 7666
 7667    @classmethod
 7668    def from_dict(cls, d):
 7669        return cls(
 7670            auth_database=d.get('auth_database'),
 7671            bind_interface=d.get('bind_interface'),
 7672            connect_to_replica=d.get('connect_to_replica'),
 7673            egress_filter=d.get('egress_filter'),
 7674            healthy=d.get('healthy'),
 7675            hostname=d.get('hostname'),
 7676            id=d.get('id'),
 7677            name=d.get('name'),
 7678            password=d.get('password'),
 7679            port=d.get('port'),
 7680            port_override=d.get('port_override'),
 7681            replica_set=d.get('replica_set'),
 7682            secret_store_id=d.get('secret_store_id'),
 7683            tags=d.get('tags'),
 7684            tls_required=d.get('tls_required'),
 7685            username=d.get('username'),
 7686        )
 7687
 7688
 7689class MongoReplicaSet:
 7690    '''
 7691    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7692    without a major version bump.
 7693    '''
 7694    __slots__ = [
 7695        'auth_database',
 7696        'bind_interface',
 7697        'connect_to_replica',
 7698        'egress_filter',
 7699        'healthy',
 7700        'hostname',
 7701        'id',
 7702        'name',
 7703        'password',
 7704        'port',
 7705        'port_override',
 7706        'replica_set',
 7707        'secret_store_id',
 7708        'tags',
 7709        'tls_required',
 7710        'username',
 7711    ]
 7712
 7713    def __init__(
 7714        self,
 7715        auth_database=None,
 7716        bind_interface=None,
 7717        connect_to_replica=None,
 7718        egress_filter=None,
 7719        healthy=None,
 7720        hostname=None,
 7721        id=None,
 7722        name=None,
 7723        password=None,
 7724        port=None,
 7725        port_override=None,
 7726        replica_set=None,
 7727        secret_store_id=None,
 7728        tags=None,
 7729        tls_required=None,
 7730        username=None,
 7731    ):
 7732        self.auth_database = auth_database if auth_database is not None else ''
 7733        self.bind_interface = bind_interface if bind_interface is not None else ''
 7734        '''
 7735         Bind interface
 7736        '''
 7737        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7738        self.egress_filter = egress_filter if egress_filter is not None else ''
 7739        '''
 7740         A filter applied to the routing logic to pin datasource to nodes.
 7741        '''
 7742        self.healthy = healthy if healthy is not None else False
 7743        '''
 7744         True if the datasource is reachable and the credentials are valid.
 7745        '''
 7746        self.hostname = hostname if hostname is not None else ''
 7747        self.id = id if id is not None else ''
 7748        '''
 7749         Unique identifier of the Resource.
 7750        '''
 7751        self.name = name if name is not None else ''
 7752        '''
 7753         Unique human-readable name of the Resource.
 7754        '''
 7755        self.password = password if password is not None else ''
 7756        self.port = port if port is not None else 0
 7757        self.port_override = port_override if port_override is not None else 0
 7758        self.replica_set = replica_set if replica_set is not None else ''
 7759        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7760        '''
 7761         ID of the secret store containing credentials for this resource, if any.
 7762        '''
 7763        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7764        '''
 7765         Tags is a map of key, value pairs.
 7766        '''
 7767        self.tls_required = tls_required if tls_required is not None else False
 7768        self.username = username if username is not None else ''
 7769
 7770    def __repr__(self):
 7771        return '<sdm.MongoReplicaSet ' + \
 7772            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7773            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7774            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7775            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7776            'healthy: ' + repr(self.healthy) + ' ' +\
 7777            'hostname: ' + repr(self.hostname) + ' ' +\
 7778            'id: ' + repr(self.id) + ' ' +\
 7779            'name: ' + repr(self.name) + ' ' +\
 7780            'password: ' + repr(self.password) + ' ' +\
 7781            'port: ' + repr(self.port) + ' ' +\
 7782            'port_override: ' + repr(self.port_override) + ' ' +\
 7783            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7784            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7785            'tags: ' + repr(self.tags) + ' ' +\
 7786            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7787            'username: ' + repr(self.username) + ' ' +\
 7788            '>'
 7789
 7790    def to_dict(self):
 7791        return {
 7792            'auth_database': self.auth_database,
 7793            'bind_interface': self.bind_interface,
 7794            'connect_to_replica': self.connect_to_replica,
 7795            'egress_filter': self.egress_filter,
 7796            'healthy': self.healthy,
 7797            'hostname': self.hostname,
 7798            'id': self.id,
 7799            'name': self.name,
 7800            'password': self.password,
 7801            'port': self.port,
 7802            'port_override': self.port_override,
 7803            'replica_set': self.replica_set,
 7804            'secret_store_id': self.secret_store_id,
 7805            'tags': self.tags,
 7806            'tls_required': self.tls_required,
 7807            'username': self.username,
 7808        }
 7809
 7810    @classmethod
 7811    def from_dict(cls, d):
 7812        return cls(
 7813            auth_database=d.get('auth_database'),
 7814            bind_interface=d.get('bind_interface'),
 7815            connect_to_replica=d.get('connect_to_replica'),
 7816            egress_filter=d.get('egress_filter'),
 7817            healthy=d.get('healthy'),
 7818            hostname=d.get('hostname'),
 7819            id=d.get('id'),
 7820            name=d.get('name'),
 7821            password=d.get('password'),
 7822            port=d.get('port'),
 7823            port_override=d.get('port_override'),
 7824            replica_set=d.get('replica_set'),
 7825            secret_store_id=d.get('secret_store_id'),
 7826            tags=d.get('tags'),
 7827            tls_required=d.get('tls_required'),
 7828            username=d.get('username'),
 7829        )
 7830
 7831
 7832class MongoShardedCluster:
 7833    '''
 7834    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 7835    without a major version bump.
 7836    '''
 7837    __slots__ = [
 7838        'auth_database',
 7839        'bind_interface',
 7840        'egress_filter',
 7841        'healthy',
 7842        'hostname',
 7843        'id',
 7844        'name',
 7845        'password',
 7846        'port_override',
 7847        'secret_store_id',
 7848        'tags',
 7849        'tls_required',
 7850        'username',
 7851    ]
 7852
 7853    def __init__(
 7854        self,
 7855        auth_database=None,
 7856        bind_interface=None,
 7857        egress_filter=None,
 7858        healthy=None,
 7859        hostname=None,
 7860        id=None,
 7861        name=None,
 7862        password=None,
 7863        port_override=None,
 7864        secret_store_id=None,
 7865        tags=None,
 7866        tls_required=None,
 7867        username=None,
 7868    ):
 7869        self.auth_database = auth_database if auth_database is not None else ''
 7870        self.bind_interface = bind_interface if bind_interface is not None else ''
 7871        '''
 7872         Bind interface
 7873        '''
 7874        self.egress_filter = egress_filter if egress_filter is not None else ''
 7875        '''
 7876         A filter applied to the routing logic to pin datasource to nodes.
 7877        '''
 7878        self.healthy = healthy if healthy is not None else False
 7879        '''
 7880         True if the datasource is reachable and the credentials are valid.
 7881        '''
 7882        self.hostname = hostname if hostname is not None else ''
 7883        self.id = id if id is not None else ''
 7884        '''
 7885         Unique identifier of the Resource.
 7886        '''
 7887        self.name = name if name is not None else ''
 7888        '''
 7889         Unique human-readable name of the Resource.
 7890        '''
 7891        self.password = password if password is not None else ''
 7892        self.port_override = port_override if port_override is not None else 0
 7893        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7894        '''
 7895         ID of the secret store containing credentials for this resource, if any.
 7896        '''
 7897        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7898        '''
 7899         Tags is a map of key, value pairs.
 7900        '''
 7901        self.tls_required = tls_required if tls_required is not None else False
 7902        self.username = username if username is not None else ''
 7903
 7904    def __repr__(self):
 7905        return '<sdm.MongoShardedCluster ' + \
 7906            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7907            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7908            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7909            'healthy: ' + repr(self.healthy) + ' ' +\
 7910            'hostname: ' + repr(self.hostname) + ' ' +\
 7911            'id: ' + repr(self.id) + ' ' +\
 7912            'name: ' + repr(self.name) + ' ' +\
 7913            'password: ' + repr(self.password) + ' ' +\
 7914            'port_override: ' + repr(self.port_override) + ' ' +\
 7915            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7916            'tags: ' + repr(self.tags) + ' ' +\
 7917            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7918            'username: ' + repr(self.username) + ' ' +\
 7919            '>'
 7920
 7921    def to_dict(self):
 7922        return {
 7923            'auth_database': self.auth_database,
 7924            'bind_interface': self.bind_interface,
 7925            'egress_filter': self.egress_filter,
 7926            'healthy': self.healthy,
 7927            'hostname': self.hostname,
 7928            'id': self.id,
 7929            'name': self.name,
 7930            'password': self.password,
 7931            'port_override': self.port_override,
 7932            'secret_store_id': self.secret_store_id,
 7933            'tags': self.tags,
 7934            'tls_required': self.tls_required,
 7935            'username': self.username,
 7936        }
 7937
 7938    @classmethod
 7939    def from_dict(cls, d):
 7940        return cls(
 7941            auth_database=d.get('auth_database'),
 7942            bind_interface=d.get('bind_interface'),
 7943            egress_filter=d.get('egress_filter'),
 7944            healthy=d.get('healthy'),
 7945            hostname=d.get('hostname'),
 7946            id=d.get('id'),
 7947            name=d.get('name'),
 7948            password=d.get('password'),
 7949            port_override=d.get('port_override'),
 7950            secret_store_id=d.get('secret_store_id'),
 7951            tags=d.get('tags'),
 7952            tls_required=d.get('tls_required'),
 7953            username=d.get('username'),
 7954        )
 7955
 7956
 7957class Mysql:
 7958    __slots__ = [
 7959        'bind_interface',
 7960        'database',
 7961        'egress_filter',
 7962        'healthy',
 7963        'hostname',
 7964        'id',
 7965        'name',
 7966        'password',
 7967        'port',
 7968        'port_override',
 7969        'secret_store_id',
 7970        'tags',
 7971        'username',
 7972    ]
 7973
 7974    def __init__(
 7975        self,
 7976        bind_interface=None,
 7977        database=None,
 7978        egress_filter=None,
 7979        healthy=None,
 7980        hostname=None,
 7981        id=None,
 7982        name=None,
 7983        password=None,
 7984        port=None,
 7985        port_override=None,
 7986        secret_store_id=None,
 7987        tags=None,
 7988        username=None,
 7989    ):
 7990        self.bind_interface = bind_interface if bind_interface is not None else ''
 7991        '''
 7992         Bind interface
 7993        '''
 7994        self.database = database if database is not None else ''
 7995        self.egress_filter = egress_filter if egress_filter is not None else ''
 7996        '''
 7997         A filter applied to the routing logic to pin datasource to nodes.
 7998        '''
 7999        self.healthy = healthy if healthy is not None else False
 8000        '''
 8001         True if the datasource is reachable and the credentials are valid.
 8002        '''
 8003        self.hostname = hostname if hostname is not None else ''
 8004        self.id = id if id is not None else ''
 8005        '''
 8006         Unique identifier of the Resource.
 8007        '''
 8008        self.name = name if name is not None else ''
 8009        '''
 8010         Unique human-readable name of the Resource.
 8011        '''
 8012        self.password = password if password is not None else ''
 8013        self.port = port if port is not None else 0
 8014        self.port_override = port_override if port_override is not None else 0
 8015        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8016        '''
 8017         ID of the secret store containing credentials for this resource, if any.
 8018        '''
 8019        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8020        '''
 8021         Tags is a map of key, value pairs.
 8022        '''
 8023        self.username = username if username is not None else ''
 8024
 8025    def __repr__(self):
 8026        return '<sdm.Mysql ' + \
 8027            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8028            'database: ' + repr(self.database) + ' ' +\
 8029            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8030            'healthy: ' + repr(self.healthy) + ' ' +\
 8031            'hostname: ' + repr(self.hostname) + ' ' +\
 8032            'id: ' + repr(self.id) + ' ' +\
 8033            'name: ' + repr(self.name) + ' ' +\
 8034            'password: ' + repr(self.password) + ' ' +\
 8035            'port: ' + repr(self.port) + ' ' +\
 8036            'port_override: ' + repr(self.port_override) + ' ' +\
 8037            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8038            'tags: ' + repr(self.tags) + ' ' +\
 8039            'username: ' + repr(self.username) + ' ' +\
 8040            '>'
 8041
 8042    def to_dict(self):
 8043        return {
 8044            'bind_interface': self.bind_interface,
 8045            'database': self.database,
 8046            'egress_filter': self.egress_filter,
 8047            'healthy': self.healthy,
 8048            'hostname': self.hostname,
 8049            'id': self.id,
 8050            'name': self.name,
 8051            'password': self.password,
 8052            'port': self.port,
 8053            'port_override': self.port_override,
 8054            'secret_store_id': self.secret_store_id,
 8055            'tags': self.tags,
 8056            'username': self.username,
 8057        }
 8058
 8059    @classmethod
 8060    def from_dict(cls, d):
 8061        return cls(
 8062            bind_interface=d.get('bind_interface'),
 8063            database=d.get('database'),
 8064            egress_filter=d.get('egress_filter'),
 8065            healthy=d.get('healthy'),
 8066            hostname=d.get('hostname'),
 8067            id=d.get('id'),
 8068            name=d.get('name'),
 8069            password=d.get('password'),
 8070            port=d.get('port'),
 8071            port_override=d.get('port_override'),
 8072            secret_store_id=d.get('secret_store_id'),
 8073            tags=d.get('tags'),
 8074            username=d.get('username'),
 8075        )
 8076
 8077
 8078class Neptune:
 8079    __slots__ = [
 8080        'bind_interface',
 8081        'egress_filter',
 8082        'endpoint',
 8083        'healthy',
 8084        'id',
 8085        'name',
 8086        'port',
 8087        'port_override',
 8088        'secret_store_id',
 8089        'tags',
 8090    ]
 8091
 8092    def __init__(
 8093        self,
 8094        bind_interface=None,
 8095        egress_filter=None,
 8096        endpoint=None,
 8097        healthy=None,
 8098        id=None,
 8099        name=None,
 8100        port=None,
 8101        port_override=None,
 8102        secret_store_id=None,
 8103        tags=None,
 8104    ):
 8105        self.bind_interface = bind_interface if bind_interface is not None else ''
 8106        '''
 8107         Bind interface
 8108        '''
 8109        self.egress_filter = egress_filter if egress_filter is not None else ''
 8110        '''
 8111         A filter applied to the routing logic to pin datasource to nodes.
 8112        '''
 8113        self.endpoint = endpoint if endpoint is not None else ''
 8114        self.healthy = healthy if healthy is not None else False
 8115        '''
 8116         True if the datasource is reachable and the credentials are valid.
 8117        '''
 8118        self.id = id if id is not None else ''
 8119        '''
 8120         Unique identifier of the Resource.
 8121        '''
 8122        self.name = name if name is not None else ''
 8123        '''
 8124         Unique human-readable name of the Resource.
 8125        '''
 8126        self.port = port if port is not None else 0
 8127        self.port_override = port_override if port_override is not None else 0
 8128        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8129        '''
 8130         ID of the secret store containing credentials for this resource, if any.
 8131        '''
 8132        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8133        '''
 8134         Tags is a map of key, value pairs.
 8135        '''
 8136
 8137    def __repr__(self):
 8138        return '<sdm.Neptune ' + \
 8139            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8140            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8141            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8142            'healthy: ' + repr(self.healthy) + ' ' +\
 8143            'id: ' + repr(self.id) + ' ' +\
 8144            'name: ' + repr(self.name) + ' ' +\
 8145            'port: ' + repr(self.port) + ' ' +\
 8146            'port_override: ' + repr(self.port_override) + ' ' +\
 8147            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8148            'tags: ' + repr(self.tags) + ' ' +\
 8149            '>'
 8150
 8151    def to_dict(self):
 8152        return {
 8153            'bind_interface': self.bind_interface,
 8154            'egress_filter': self.egress_filter,
 8155            'endpoint': self.endpoint,
 8156            'healthy': self.healthy,
 8157            'id': self.id,
 8158            'name': self.name,
 8159            'port': self.port,
 8160            'port_override': self.port_override,
 8161            'secret_store_id': self.secret_store_id,
 8162            'tags': self.tags,
 8163        }
 8164
 8165    @classmethod
 8166    def from_dict(cls, d):
 8167        return cls(
 8168            bind_interface=d.get('bind_interface'),
 8169            egress_filter=d.get('egress_filter'),
 8170            endpoint=d.get('endpoint'),
 8171            healthy=d.get('healthy'),
 8172            id=d.get('id'),
 8173            name=d.get('name'),
 8174            port=d.get('port'),
 8175            port_override=d.get('port_override'),
 8176            secret_store_id=d.get('secret_store_id'),
 8177            tags=d.get('tags'),
 8178        )
 8179
 8180
 8181class NeptuneIAM:
 8182    __slots__ = [
 8183        'access_key',
 8184        'bind_interface',
 8185        'egress_filter',
 8186        'endpoint',
 8187        'healthy',
 8188        'id',
 8189        'name',
 8190        'port',
 8191        'port_override',
 8192        'region',
 8193        'role_arn',
 8194        'role_external_id',
 8195        'secret_access_key',
 8196        'secret_store_id',
 8197        'tags',
 8198    ]
 8199
 8200    def __init__(
 8201        self,
 8202        access_key=None,
 8203        bind_interface=None,
 8204        egress_filter=None,
 8205        endpoint=None,
 8206        healthy=None,
 8207        id=None,
 8208        name=None,
 8209        port=None,
 8210        port_override=None,
 8211        region=None,
 8212        role_arn=None,
 8213        role_external_id=None,
 8214        secret_access_key=None,
 8215        secret_store_id=None,
 8216        tags=None,
 8217    ):
 8218        self.access_key = access_key if access_key is not None else ''
 8219        self.bind_interface = bind_interface if bind_interface is not None else ''
 8220        '''
 8221         Bind interface
 8222        '''
 8223        self.egress_filter = egress_filter if egress_filter is not None else ''
 8224        '''
 8225         A filter applied to the routing logic to pin datasource to nodes.
 8226        '''
 8227        self.endpoint = endpoint if endpoint is not None else ''
 8228        self.healthy = healthy if healthy is not None else False
 8229        '''
 8230         True if the datasource is reachable and the credentials are valid.
 8231        '''
 8232        self.id = id if id is not None else ''
 8233        '''
 8234         Unique identifier of the Resource.
 8235        '''
 8236        self.name = name if name is not None else ''
 8237        '''
 8238         Unique human-readable name of the Resource.
 8239        '''
 8240        self.port = port if port is not None else 0
 8241        self.port_override = port_override if port_override is not None else 0
 8242        self.region = region if region is not None else ''
 8243        self.role_arn = role_arn if role_arn is not None else ''
 8244        self.role_external_id = role_external_id if role_external_id is not None else ''
 8245        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8246        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8247        '''
 8248         ID of the secret store containing credentials for this resource, if any.
 8249        '''
 8250        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8251        '''
 8252         Tags is a map of key, value pairs.
 8253        '''
 8254
 8255    def __repr__(self):
 8256        return '<sdm.NeptuneIAM ' + \
 8257            'access_key: ' + repr(self.access_key) + ' ' +\
 8258            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8259            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8260            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8261            'healthy: ' + repr(self.healthy) + ' ' +\
 8262            'id: ' + repr(self.id) + ' ' +\
 8263            'name: ' + repr(self.name) + ' ' +\
 8264            'port: ' + repr(self.port) + ' ' +\
 8265            'port_override: ' + repr(self.port_override) + ' ' +\
 8266            'region: ' + repr(self.region) + ' ' +\
 8267            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8268            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8269            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8270            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8271            'tags: ' + repr(self.tags) + ' ' +\
 8272            '>'
 8273
 8274    def to_dict(self):
 8275        return {
 8276            'access_key': self.access_key,
 8277            'bind_interface': self.bind_interface,
 8278            'egress_filter': self.egress_filter,
 8279            'endpoint': self.endpoint,
 8280            'healthy': self.healthy,
 8281            'id': self.id,
 8282            'name': self.name,
 8283            'port': self.port,
 8284            'port_override': self.port_override,
 8285            'region': self.region,
 8286            'role_arn': self.role_arn,
 8287            'role_external_id': self.role_external_id,
 8288            'secret_access_key': self.secret_access_key,
 8289            'secret_store_id': self.secret_store_id,
 8290            'tags': self.tags,
 8291        }
 8292
 8293    @classmethod
 8294    def from_dict(cls, d):
 8295        return cls(
 8296            access_key=d.get('access_key'),
 8297            bind_interface=d.get('bind_interface'),
 8298            egress_filter=d.get('egress_filter'),
 8299            endpoint=d.get('endpoint'),
 8300            healthy=d.get('healthy'),
 8301            id=d.get('id'),
 8302            name=d.get('name'),
 8303            port=d.get('port'),
 8304            port_override=d.get('port_override'),
 8305            region=d.get('region'),
 8306            role_arn=d.get('role_arn'),
 8307            role_external_id=d.get('role_external_id'),
 8308            secret_access_key=d.get('secret_access_key'),
 8309            secret_store_id=d.get('secret_store_id'),
 8310            tags=d.get('tags'),
 8311        )
 8312
 8313
 8314class NodeCreateResponse:
 8315    '''
 8316         NodeCreateResponse reports how the Nodes were created in the system.
 8317    '''
 8318    __slots__ = [
 8319        'meta',
 8320        'node',
 8321        'rate_limit',
 8322        'token',
 8323    ]
 8324
 8325    def __init__(
 8326        self,
 8327        meta=None,
 8328        node=None,
 8329        rate_limit=None,
 8330        token=None,
 8331    ):
 8332        self.meta = meta if meta is not None else None
 8333        '''
 8334         Reserved for future use.
 8335        '''
 8336        self.node = node if node is not None else None
 8337        '''
 8338         The created Node.
 8339        '''
 8340        self.rate_limit = rate_limit if rate_limit is not None else None
 8341        '''
 8342         Rate limit information.
 8343        '''
 8344        self.token = token if token is not None else ''
 8345        '''
 8346         The auth token generated for the Node. The Node will use this token to
 8347         authenticate with the strongDM API.
 8348        '''
 8349
 8350    def __repr__(self):
 8351        return '<sdm.NodeCreateResponse ' + \
 8352            'meta: ' + repr(self.meta) + ' ' +\
 8353            'node: ' + repr(self.node) + ' ' +\
 8354            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8355            'token: ' + repr(self.token) + ' ' +\
 8356            '>'
 8357
 8358    def to_dict(self):
 8359        return {
 8360            'meta': self.meta,
 8361            'node': self.node,
 8362            'rate_limit': self.rate_limit,
 8363            'token': self.token,
 8364        }
 8365
 8366    @classmethod
 8367    def from_dict(cls, d):
 8368        return cls(
 8369            meta=d.get('meta'),
 8370            node=d.get('node'),
 8371            rate_limit=d.get('rate_limit'),
 8372            token=d.get('token'),
 8373        )
 8374
 8375
 8376class NodeDeleteResponse:
 8377    '''
 8378         NodeDeleteResponse returns information about a Node that was deleted.
 8379    '''
 8380    __slots__ = [
 8381        'meta',
 8382        'rate_limit',
 8383    ]
 8384
 8385    def __init__(
 8386        self,
 8387        meta=None,
 8388        rate_limit=None,
 8389    ):
 8390        self.meta = meta if meta is not None else None
 8391        '''
 8392         Reserved for future use.
 8393        '''
 8394        self.rate_limit = rate_limit if rate_limit is not None else None
 8395        '''
 8396         Rate limit information.
 8397        '''
 8398
 8399    def __repr__(self):
 8400        return '<sdm.NodeDeleteResponse ' + \
 8401            'meta: ' + repr(self.meta) + ' ' +\
 8402            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8403            '>'
 8404
 8405    def to_dict(self):
 8406        return {
 8407            'meta': self.meta,
 8408            'rate_limit': self.rate_limit,
 8409        }
 8410
 8411    @classmethod
 8412    def from_dict(cls, d):
 8413        return cls(
 8414            meta=d.get('meta'),
 8415            rate_limit=d.get('rate_limit'),
 8416        )
 8417
 8418
 8419class NodeGetResponse:
 8420    '''
 8421         NodeGetResponse returns a requested Node.
 8422    '''
 8423    __slots__ = [
 8424        'meta',
 8425        'node',
 8426        'rate_limit',
 8427    ]
 8428
 8429    def __init__(
 8430        self,
 8431        meta=None,
 8432        node=None,
 8433        rate_limit=None,
 8434    ):
 8435        self.meta = meta if meta is not None else None
 8436        '''
 8437         Reserved for future use.
 8438        '''
 8439        self.node = node if node is not None else None
 8440        '''
 8441         The requested Node.
 8442        '''
 8443        self.rate_limit = rate_limit if rate_limit is not None else None
 8444        '''
 8445         Rate limit information.
 8446        '''
 8447
 8448    def __repr__(self):
 8449        return '<sdm.NodeGetResponse ' + \
 8450            'meta: ' + repr(self.meta) + ' ' +\
 8451            'node: ' + repr(self.node) + ' ' +\
 8452            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8453            '>'
 8454
 8455    def to_dict(self):
 8456        return {
 8457            'meta': self.meta,
 8458            'node': self.node,
 8459            'rate_limit': self.rate_limit,
 8460        }
 8461
 8462    @classmethod
 8463    def from_dict(cls, d):
 8464        return cls(
 8465            meta=d.get('meta'),
 8466            node=d.get('node'),
 8467            rate_limit=d.get('rate_limit'),
 8468        )
 8469
 8470
 8471class NodeUpdateResponse:
 8472    '''
 8473         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8474     a NodeUpdateRequest.
 8475    '''
 8476    __slots__ = [
 8477        'meta',
 8478        'node',
 8479        'rate_limit',
 8480    ]
 8481
 8482    def __init__(
 8483        self,
 8484        meta=None,
 8485        node=None,
 8486        rate_limit=None,
 8487    ):
 8488        self.meta = meta if meta is not None else None
 8489        '''
 8490         Reserved for future use.
 8491        '''
 8492        self.node = node if node is not None else None
 8493        '''
 8494         The updated Node.
 8495        '''
 8496        self.rate_limit = rate_limit if rate_limit is not None else None
 8497        '''
 8498         Rate limit information.
 8499        '''
 8500
 8501    def __repr__(self):
 8502        return '<sdm.NodeUpdateResponse ' + \
 8503            'meta: ' + repr(self.meta) + ' ' +\
 8504            'node: ' + repr(self.node) + ' ' +\
 8505            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8506            '>'
 8507
 8508    def to_dict(self):
 8509        return {
 8510            'meta': self.meta,
 8511            'node': self.node,
 8512            'rate_limit': self.rate_limit,
 8513        }
 8514
 8515    @classmethod
 8516    def from_dict(cls, d):
 8517        return cls(
 8518            meta=d.get('meta'),
 8519            node=d.get('node'),
 8520            rate_limit=d.get('rate_limit'),
 8521        )
 8522
 8523
 8524class Oracle:
 8525    __slots__ = [
 8526        'bind_interface',
 8527        'database',
 8528        'egress_filter',
 8529        'healthy',
 8530        'hostname',
 8531        'id',
 8532        'name',
 8533        'password',
 8534        'port',
 8535        'port_override',
 8536        'secret_store_id',
 8537        'tags',
 8538        'tls_required',
 8539        'username',
 8540    ]
 8541
 8542    def __init__(
 8543        self,
 8544        bind_interface=None,
 8545        database=None,
 8546        egress_filter=None,
 8547        healthy=None,
 8548        hostname=None,
 8549        id=None,
 8550        name=None,
 8551        password=None,
 8552        port=None,
 8553        port_override=None,
 8554        secret_store_id=None,
 8555        tags=None,
 8556        tls_required=None,
 8557        username=None,
 8558    ):
 8559        self.bind_interface = bind_interface if bind_interface is not None else ''
 8560        '''
 8561         Bind interface
 8562        '''
 8563        self.database = database if database is not None else ''
 8564        self.egress_filter = egress_filter if egress_filter is not None else ''
 8565        '''
 8566         A filter applied to the routing logic to pin datasource to nodes.
 8567        '''
 8568        self.healthy = healthy if healthy is not None else False
 8569        '''
 8570         True if the datasource is reachable and the credentials are valid.
 8571        '''
 8572        self.hostname = hostname if hostname is not None else ''
 8573        self.id = id if id is not None else ''
 8574        '''
 8575         Unique identifier of the Resource.
 8576        '''
 8577        self.name = name if name is not None else ''
 8578        '''
 8579         Unique human-readable name of the Resource.
 8580        '''
 8581        self.password = password if password is not None else ''
 8582        self.port = port if port is not None else 0
 8583        self.port_override = port_override if port_override is not None else 0
 8584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8585        '''
 8586         ID of the secret store containing credentials for this resource, if any.
 8587        '''
 8588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8589        '''
 8590         Tags is a map of key, value pairs.
 8591        '''
 8592        self.tls_required = tls_required if tls_required is not None else False
 8593        self.username = username if username is not None else ''
 8594
 8595    def __repr__(self):
 8596        return '<sdm.Oracle ' + \
 8597            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8598            'database: ' + repr(self.database) + ' ' +\
 8599            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8600            'healthy: ' + repr(self.healthy) + ' ' +\
 8601            'hostname: ' + repr(self.hostname) + ' ' +\
 8602            'id: ' + repr(self.id) + ' ' +\
 8603            'name: ' + repr(self.name) + ' ' +\
 8604            'password: ' + repr(self.password) + ' ' +\
 8605            'port: ' + repr(self.port) + ' ' +\
 8606            'port_override: ' + repr(self.port_override) + ' ' +\
 8607            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8608            'tags: ' + repr(self.tags) + ' ' +\
 8609            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8610            'username: ' + repr(self.username) + ' ' +\
 8611            '>'
 8612
 8613    def to_dict(self):
 8614        return {
 8615            'bind_interface': self.bind_interface,
 8616            'database': self.database,
 8617            'egress_filter': self.egress_filter,
 8618            'healthy': self.healthy,
 8619            'hostname': self.hostname,
 8620            'id': self.id,
 8621            'name': self.name,
 8622            'password': self.password,
 8623            'port': self.port,
 8624            'port_override': self.port_override,
 8625            'secret_store_id': self.secret_store_id,
 8626            'tags': self.tags,
 8627            'tls_required': self.tls_required,
 8628            'username': self.username,
 8629        }
 8630
 8631    @classmethod
 8632    def from_dict(cls, d):
 8633        return cls(
 8634            bind_interface=d.get('bind_interface'),
 8635            database=d.get('database'),
 8636            egress_filter=d.get('egress_filter'),
 8637            healthy=d.get('healthy'),
 8638            hostname=d.get('hostname'),
 8639            id=d.get('id'),
 8640            name=d.get('name'),
 8641            password=d.get('password'),
 8642            port=d.get('port'),
 8643            port_override=d.get('port_override'),
 8644            secret_store_id=d.get('secret_store_id'),
 8645            tags=d.get('tags'),
 8646            tls_required=d.get('tls_required'),
 8647            username=d.get('username'),
 8648        )
 8649
 8650
 8651class Postgres:
 8652    __slots__ = [
 8653        'bind_interface',
 8654        'database',
 8655        'egress_filter',
 8656        'healthy',
 8657        'hostname',
 8658        'id',
 8659        'name',
 8660        'override_database',
 8661        'password',
 8662        'port',
 8663        'port_override',
 8664        'secret_store_id',
 8665        'tags',
 8666        'username',
 8667    ]
 8668
 8669    def __init__(
 8670        self,
 8671        bind_interface=None,
 8672        database=None,
 8673        egress_filter=None,
 8674        healthy=None,
 8675        hostname=None,
 8676        id=None,
 8677        name=None,
 8678        override_database=None,
 8679        password=None,
 8680        port=None,
 8681        port_override=None,
 8682        secret_store_id=None,
 8683        tags=None,
 8684        username=None,
 8685    ):
 8686        self.bind_interface = bind_interface if bind_interface is not None else ''
 8687        '''
 8688         Bind interface
 8689        '''
 8690        self.database = database if database is not None else ''
 8691        self.egress_filter = egress_filter if egress_filter is not None else ''
 8692        '''
 8693         A filter applied to the routing logic to pin datasource to nodes.
 8694        '''
 8695        self.healthy = healthy if healthy is not None else False
 8696        '''
 8697         True if the datasource is reachable and the credentials are valid.
 8698        '''
 8699        self.hostname = hostname if hostname is not None else ''
 8700        self.id = id if id is not None else ''
 8701        '''
 8702         Unique identifier of the Resource.
 8703        '''
 8704        self.name = name if name is not None else ''
 8705        '''
 8706         Unique human-readable name of the Resource.
 8707        '''
 8708        self.override_database = override_database if override_database is not None else False
 8709        self.password = password if password is not None else ''
 8710        self.port = port if port is not None else 0
 8711        self.port_override = port_override if port_override is not None else 0
 8712        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8713        '''
 8714         ID of the secret store containing credentials for this resource, if any.
 8715        '''
 8716        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8717        '''
 8718         Tags is a map of key, value pairs.
 8719        '''
 8720        self.username = username if username is not None else ''
 8721
 8722    def __repr__(self):
 8723        return '<sdm.Postgres ' + \
 8724            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8725            'database: ' + repr(self.database) + ' ' +\
 8726            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8727            'healthy: ' + repr(self.healthy) + ' ' +\
 8728            'hostname: ' + repr(self.hostname) + ' ' +\
 8729            'id: ' + repr(self.id) + ' ' +\
 8730            'name: ' + repr(self.name) + ' ' +\
 8731            'override_database: ' + repr(self.override_database) + ' ' +\
 8732            'password: ' + repr(self.password) + ' ' +\
 8733            'port: ' + repr(self.port) + ' ' +\
 8734            'port_override: ' + repr(self.port_override) + ' ' +\
 8735            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8736            'tags: ' + repr(self.tags) + ' ' +\
 8737            'username: ' + repr(self.username) + ' ' +\
 8738            '>'
 8739
 8740    def to_dict(self):
 8741        return {
 8742            'bind_interface': self.bind_interface,
 8743            'database': self.database,
 8744            'egress_filter': self.egress_filter,
 8745            'healthy': self.healthy,
 8746            'hostname': self.hostname,
 8747            'id': self.id,
 8748            'name': self.name,
 8749            'override_database': self.override_database,
 8750            'password': self.password,
 8751            'port': self.port,
 8752            'port_override': self.port_override,
 8753            'secret_store_id': self.secret_store_id,
 8754            'tags': self.tags,
 8755            'username': self.username,
 8756        }
 8757
 8758    @classmethod
 8759    def from_dict(cls, d):
 8760        return cls(
 8761            bind_interface=d.get('bind_interface'),
 8762            database=d.get('database'),
 8763            egress_filter=d.get('egress_filter'),
 8764            healthy=d.get('healthy'),
 8765            hostname=d.get('hostname'),
 8766            id=d.get('id'),
 8767            name=d.get('name'),
 8768            override_database=d.get('override_database'),
 8769            password=d.get('password'),
 8770            port=d.get('port'),
 8771            port_override=d.get('port_override'),
 8772            secret_store_id=d.get('secret_store_id'),
 8773            tags=d.get('tags'),
 8774            username=d.get('username'),
 8775        )
 8776
 8777
 8778class Presto:
 8779    __slots__ = [
 8780        'bind_interface',
 8781        'database',
 8782        'egress_filter',
 8783        'healthy',
 8784        'hostname',
 8785        'id',
 8786        'name',
 8787        'password',
 8788        'port',
 8789        'port_override',
 8790        'secret_store_id',
 8791        'tags',
 8792        'tls_required',
 8793        'username',
 8794    ]
 8795
 8796    def __init__(
 8797        self,
 8798        bind_interface=None,
 8799        database=None,
 8800        egress_filter=None,
 8801        healthy=None,
 8802        hostname=None,
 8803        id=None,
 8804        name=None,
 8805        password=None,
 8806        port=None,
 8807        port_override=None,
 8808        secret_store_id=None,
 8809        tags=None,
 8810        tls_required=None,
 8811        username=None,
 8812    ):
 8813        self.bind_interface = bind_interface if bind_interface is not None else ''
 8814        '''
 8815         Bind interface
 8816        '''
 8817        self.database = database if database is not None else ''
 8818        self.egress_filter = egress_filter if egress_filter is not None else ''
 8819        '''
 8820         A filter applied to the routing logic to pin datasource to nodes.
 8821        '''
 8822        self.healthy = healthy if healthy is not None else False
 8823        '''
 8824         True if the datasource is reachable and the credentials are valid.
 8825        '''
 8826        self.hostname = hostname if hostname is not None else ''
 8827        self.id = id if id is not None else ''
 8828        '''
 8829         Unique identifier of the Resource.
 8830        '''
 8831        self.name = name if name is not None else ''
 8832        '''
 8833         Unique human-readable name of the Resource.
 8834        '''
 8835        self.password = password if password is not None else ''
 8836        self.port = port if port is not None else 0
 8837        self.port_override = port_override if port_override is not None else 0
 8838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8839        '''
 8840         ID of the secret store containing credentials for this resource, if any.
 8841        '''
 8842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8843        '''
 8844         Tags is a map of key, value pairs.
 8845        '''
 8846        self.tls_required = tls_required if tls_required is not None else False
 8847        self.username = username if username is not None else ''
 8848
 8849    def __repr__(self):
 8850        return '<sdm.Presto ' + \
 8851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8852            'database: ' + repr(self.database) + ' ' +\
 8853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8854            'healthy: ' + repr(self.healthy) + ' ' +\
 8855            'hostname: ' + repr(self.hostname) + ' ' +\
 8856            'id: ' + repr(self.id) + ' ' +\
 8857            'name: ' + repr(self.name) + ' ' +\
 8858            'password: ' + repr(self.password) + ' ' +\
 8859            'port: ' + repr(self.port) + ' ' +\
 8860            'port_override: ' + repr(self.port_override) + ' ' +\
 8861            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8862            'tags: ' + repr(self.tags) + ' ' +\
 8863            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8864            'username: ' + repr(self.username) + ' ' +\
 8865            '>'
 8866
 8867    def to_dict(self):
 8868        return {
 8869            'bind_interface': self.bind_interface,
 8870            'database': self.database,
 8871            'egress_filter': self.egress_filter,
 8872            'healthy': self.healthy,
 8873            'hostname': self.hostname,
 8874            'id': self.id,
 8875            'name': self.name,
 8876            'password': self.password,
 8877            'port': self.port,
 8878            'port_override': self.port_override,
 8879            'secret_store_id': self.secret_store_id,
 8880            'tags': self.tags,
 8881            'tls_required': self.tls_required,
 8882            'username': self.username,
 8883        }
 8884
 8885    @classmethod
 8886    def from_dict(cls, d):
 8887        return cls(
 8888            bind_interface=d.get('bind_interface'),
 8889            database=d.get('database'),
 8890            egress_filter=d.get('egress_filter'),
 8891            healthy=d.get('healthy'),
 8892            hostname=d.get('hostname'),
 8893            id=d.get('id'),
 8894            name=d.get('name'),
 8895            password=d.get('password'),
 8896            port=d.get('port'),
 8897            port_override=d.get('port_override'),
 8898            secret_store_id=d.get('secret_store_id'),
 8899            tags=d.get('tags'),
 8900            tls_required=d.get('tls_required'),
 8901            username=d.get('username'),
 8902        )
 8903
 8904
 8905class RDP:
 8906    __slots__ = [
 8907        'bind_interface',
 8908        'downgrade_nla_connections',
 8909        'egress_filter',
 8910        'healthy',
 8911        'hostname',
 8912        'id',
 8913        'name',
 8914        'password',
 8915        'port',
 8916        'port_override',
 8917        'secret_store_id',
 8918        'tags',
 8919        'username',
 8920    ]
 8921
 8922    def __init__(
 8923        self,
 8924        bind_interface=None,
 8925        downgrade_nla_connections=None,
 8926        egress_filter=None,
 8927        healthy=None,
 8928        hostname=None,
 8929        id=None,
 8930        name=None,
 8931        password=None,
 8932        port=None,
 8933        port_override=None,
 8934        secret_store_id=None,
 8935        tags=None,
 8936        username=None,
 8937    ):
 8938        self.bind_interface = bind_interface if bind_interface is not None else ''
 8939        '''
 8940         Bind interface
 8941        '''
 8942        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 8943        self.egress_filter = egress_filter if egress_filter is not None else ''
 8944        '''
 8945         A filter applied to the routing logic to pin datasource to nodes.
 8946        '''
 8947        self.healthy = healthy if healthy is not None else False
 8948        '''
 8949         True if the datasource is reachable and the credentials are valid.
 8950        '''
 8951        self.hostname = hostname if hostname is not None else ''
 8952        self.id = id if id is not None else ''
 8953        '''
 8954         Unique identifier of the Resource.
 8955        '''
 8956        self.name = name if name is not None else ''
 8957        '''
 8958         Unique human-readable name of the Resource.
 8959        '''
 8960        self.password = password if password is not None else ''
 8961        self.port = port if port is not None else 0
 8962        self.port_override = port_override if port_override is not None else 0
 8963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8964        '''
 8965         ID of the secret store containing credentials for this resource, if any.
 8966        '''
 8967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8968        '''
 8969         Tags is a map of key, value pairs.
 8970        '''
 8971        self.username = username if username is not None else ''
 8972
 8973    def __repr__(self):
 8974        return '<sdm.RDP ' + \
 8975            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8976            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 8977            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8978            'healthy: ' + repr(self.healthy) + ' ' +\
 8979            'hostname: ' + repr(self.hostname) + ' ' +\
 8980            'id: ' + repr(self.id) + ' ' +\
 8981            'name: ' + repr(self.name) + ' ' +\
 8982            'password: ' + repr(self.password) + ' ' +\
 8983            'port: ' + repr(self.port) + ' ' +\
 8984            'port_override: ' + repr(self.port_override) + ' ' +\
 8985            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8986            'tags: ' + repr(self.tags) + ' ' +\
 8987            'username: ' + repr(self.username) + ' ' +\
 8988            '>'
 8989
 8990    def to_dict(self):
 8991        return {
 8992            'bind_interface': self.bind_interface,
 8993            'downgrade_nla_connections': self.downgrade_nla_connections,
 8994            'egress_filter': self.egress_filter,
 8995            'healthy': self.healthy,
 8996            'hostname': self.hostname,
 8997            'id': self.id,
 8998            'name': self.name,
 8999            'password': self.password,
 9000            'port': self.port,
 9001            'port_override': self.port_override,
 9002            'secret_store_id': self.secret_store_id,
 9003            'tags': self.tags,
 9004            'username': self.username,
 9005        }
 9006
 9007    @classmethod
 9008    def from_dict(cls, d):
 9009        return cls(
 9010            bind_interface=d.get('bind_interface'),
 9011            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9012            egress_filter=d.get('egress_filter'),
 9013            healthy=d.get('healthy'),
 9014            hostname=d.get('hostname'),
 9015            id=d.get('id'),
 9016            name=d.get('name'),
 9017            password=d.get('password'),
 9018            port=d.get('port'),
 9019            port_override=d.get('port_override'),
 9020            secret_store_id=d.get('secret_store_id'),
 9021            tags=d.get('tags'),
 9022            username=d.get('username'),
 9023        )
 9024
 9025
 9026class RabbitMQAMQP091:
 9027    __slots__ = [
 9028        'bind_interface',
 9029        'egress_filter',
 9030        'healthy',
 9031        'hostname',
 9032        'id',
 9033        'name',
 9034        'password',
 9035        'port',
 9036        'port_override',
 9037        'secret_store_id',
 9038        'tags',
 9039        'tls_required',
 9040        'username',
 9041    ]
 9042
 9043    def __init__(
 9044        self,
 9045        bind_interface=None,
 9046        egress_filter=None,
 9047        healthy=None,
 9048        hostname=None,
 9049        id=None,
 9050        name=None,
 9051        password=None,
 9052        port=None,
 9053        port_override=None,
 9054        secret_store_id=None,
 9055        tags=None,
 9056        tls_required=None,
 9057        username=None,
 9058    ):
 9059        self.bind_interface = bind_interface if bind_interface is not None else ''
 9060        '''
 9061         Bind interface
 9062        '''
 9063        self.egress_filter = egress_filter if egress_filter is not None else ''
 9064        '''
 9065         A filter applied to the routing logic to pin datasource to nodes.
 9066        '''
 9067        self.healthy = healthy if healthy is not None else False
 9068        '''
 9069         True if the datasource is reachable and the credentials are valid.
 9070        '''
 9071        self.hostname = hostname if hostname is not None else ''
 9072        self.id = id if id is not None else ''
 9073        '''
 9074         Unique identifier of the Resource.
 9075        '''
 9076        self.name = name if name is not None else ''
 9077        '''
 9078         Unique human-readable name of the Resource.
 9079        '''
 9080        self.password = password if password is not None else ''
 9081        self.port = port if port is not None else 0
 9082        self.port_override = port_override if port_override is not None else 0
 9083        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9084        '''
 9085         ID of the secret store containing credentials for this resource, if any.
 9086        '''
 9087        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9088        '''
 9089         Tags is a map of key, value pairs.
 9090        '''
 9091        self.tls_required = tls_required if tls_required is not None else False
 9092        self.username = username if username is not None else ''
 9093
 9094    def __repr__(self):
 9095        return '<sdm.RabbitMQAMQP091 ' + \
 9096            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9097            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9098            'healthy: ' + repr(self.healthy) + ' ' +\
 9099            'hostname: ' + repr(self.hostname) + ' ' +\
 9100            'id: ' + repr(self.id) + ' ' +\
 9101            'name: ' + repr(self.name) + ' ' +\
 9102            'password: ' + repr(self.password) + ' ' +\
 9103            'port: ' + repr(self.port) + ' ' +\
 9104            'port_override: ' + repr(self.port_override) + ' ' +\
 9105            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9106            'tags: ' + repr(self.tags) + ' ' +\
 9107            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9108            'username: ' + repr(self.username) + ' ' +\
 9109            '>'
 9110
 9111    def to_dict(self):
 9112        return {
 9113            'bind_interface': self.bind_interface,
 9114            'egress_filter': self.egress_filter,
 9115            'healthy': self.healthy,
 9116            'hostname': self.hostname,
 9117            'id': self.id,
 9118            'name': self.name,
 9119            'password': self.password,
 9120            'port': self.port,
 9121            'port_override': self.port_override,
 9122            'secret_store_id': self.secret_store_id,
 9123            'tags': self.tags,
 9124            'tls_required': self.tls_required,
 9125            'username': self.username,
 9126        }
 9127
 9128    @classmethod
 9129    def from_dict(cls, d):
 9130        return cls(
 9131            bind_interface=d.get('bind_interface'),
 9132            egress_filter=d.get('egress_filter'),
 9133            healthy=d.get('healthy'),
 9134            hostname=d.get('hostname'),
 9135            id=d.get('id'),
 9136            name=d.get('name'),
 9137            password=d.get('password'),
 9138            port=d.get('port'),
 9139            port_override=d.get('port_override'),
 9140            secret_store_id=d.get('secret_store_id'),
 9141            tags=d.get('tags'),
 9142            tls_required=d.get('tls_required'),
 9143            username=d.get('username'),
 9144        )
 9145
 9146
 9147class RateLimitMetadata:
 9148    '''
 9149         RateLimitMetadata contains information about remaining requests avaialable
 9150     to the user over some timeframe.
 9151    '''
 9152    __slots__ = [
 9153        'bucket',
 9154        'limit',
 9155        'remaining',
 9156        'reset_at',
 9157    ]
 9158
 9159    def __init__(
 9160        self,
 9161        bucket=None,
 9162        limit=None,
 9163        remaining=None,
 9164        reset_at=None,
 9165    ):
 9166        self.bucket = bucket if bucket is not None else ''
 9167        '''
 9168         The bucket this user/token is associated with, which may be shared between
 9169         multiple users/tokens.
 9170        '''
 9171        self.limit = limit if limit is not None else 0
 9172        '''
 9173         How many total requests the user/token is authorized to make before being
 9174         rate limited.
 9175        '''
 9176        self.remaining = remaining if remaining is not None else 0
 9177        '''
 9178         How many remaining requests out of the limit are still avaialable.
 9179        '''
 9180        self.reset_at = reset_at if reset_at is not None else None
 9181        '''
 9182         The time when remaining will be reset to limit.
 9183        '''
 9184
 9185    def __repr__(self):
 9186        return '<sdm.RateLimitMetadata ' + \
 9187            'bucket: ' + repr(self.bucket) + ' ' +\
 9188            'limit: ' + repr(self.limit) + ' ' +\
 9189            'remaining: ' + repr(self.remaining) + ' ' +\
 9190            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9191            '>'
 9192
 9193    def to_dict(self):
 9194        return {
 9195            'bucket': self.bucket,
 9196            'limit': self.limit,
 9197            'remaining': self.remaining,
 9198            'reset_at': self.reset_at,
 9199        }
 9200
 9201    @classmethod
 9202    def from_dict(cls, d):
 9203        return cls(
 9204            bucket=d.get('bucket'),
 9205            limit=d.get('limit'),
 9206            remaining=d.get('remaining'),
 9207            reset_at=d.get('reset_at'),
 9208        )
 9209
 9210
 9211class RawTCP:
 9212    __slots__ = [
 9213        'bind_interface',
 9214        'egress_filter',
 9215        'healthy',
 9216        'hostname',
 9217        'id',
 9218        'name',
 9219        'port',
 9220        'port_override',
 9221        'secret_store_id',
 9222        'tags',
 9223    ]
 9224
 9225    def __init__(
 9226        self,
 9227        bind_interface=None,
 9228        egress_filter=None,
 9229        healthy=None,
 9230        hostname=None,
 9231        id=None,
 9232        name=None,
 9233        port=None,
 9234        port_override=None,
 9235        secret_store_id=None,
 9236        tags=None,
 9237    ):
 9238        self.bind_interface = bind_interface if bind_interface is not None else ''
 9239        '''
 9240         Bind interface
 9241        '''
 9242        self.egress_filter = egress_filter if egress_filter is not None else ''
 9243        '''
 9244         A filter applied to the routing logic to pin datasource to nodes.
 9245        '''
 9246        self.healthy = healthy if healthy is not None else False
 9247        '''
 9248         True if the datasource is reachable and the credentials are valid.
 9249        '''
 9250        self.hostname = hostname if hostname is not None else ''
 9251        self.id = id if id is not None else ''
 9252        '''
 9253         Unique identifier of the Resource.
 9254        '''
 9255        self.name = name if name is not None else ''
 9256        '''
 9257         Unique human-readable name of the Resource.
 9258        '''
 9259        self.port = port if port is not None else 0
 9260        self.port_override = port_override if port_override is not None else 0
 9261        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9262        '''
 9263         ID of the secret store containing credentials for this resource, if any.
 9264        '''
 9265        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9266        '''
 9267         Tags is a map of key, value pairs.
 9268        '''
 9269
 9270    def __repr__(self):
 9271        return '<sdm.RawTCP ' + \
 9272            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9273            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9274            'healthy: ' + repr(self.healthy) + ' ' +\
 9275            'hostname: ' + repr(self.hostname) + ' ' +\
 9276            'id: ' + repr(self.id) + ' ' +\
 9277            'name: ' + repr(self.name) + ' ' +\
 9278            'port: ' + repr(self.port) + ' ' +\
 9279            'port_override: ' + repr(self.port_override) + ' ' +\
 9280            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9281            'tags: ' + repr(self.tags) + ' ' +\
 9282            '>'
 9283
 9284    def to_dict(self):
 9285        return {
 9286            'bind_interface': self.bind_interface,
 9287            'egress_filter': self.egress_filter,
 9288            'healthy': self.healthy,
 9289            'hostname': self.hostname,
 9290            'id': self.id,
 9291            'name': self.name,
 9292            'port': self.port,
 9293            'port_override': self.port_override,
 9294            'secret_store_id': self.secret_store_id,
 9295            'tags': self.tags,
 9296        }
 9297
 9298    @classmethod
 9299    def from_dict(cls, d):
 9300        return cls(
 9301            bind_interface=d.get('bind_interface'),
 9302            egress_filter=d.get('egress_filter'),
 9303            healthy=d.get('healthy'),
 9304            hostname=d.get('hostname'),
 9305            id=d.get('id'),
 9306            name=d.get('name'),
 9307            port=d.get('port'),
 9308            port_override=d.get('port_override'),
 9309            secret_store_id=d.get('secret_store_id'),
 9310            tags=d.get('tags'),
 9311        )
 9312
 9313
 9314class Redis:
 9315    __slots__ = [
 9316        'bind_interface',
 9317        'egress_filter',
 9318        'healthy',
 9319        'hostname',
 9320        'id',
 9321        'name',
 9322        'password',
 9323        'port',
 9324        'port_override',
 9325        'secret_store_id',
 9326        'tags',
 9327    ]
 9328
 9329    def __init__(
 9330        self,
 9331        bind_interface=None,
 9332        egress_filter=None,
 9333        healthy=None,
 9334        hostname=None,
 9335        id=None,
 9336        name=None,
 9337        password=None,
 9338        port=None,
 9339        port_override=None,
 9340        secret_store_id=None,
 9341        tags=None,
 9342    ):
 9343        self.bind_interface = bind_interface if bind_interface is not None else ''
 9344        '''
 9345         Bind interface
 9346        '''
 9347        self.egress_filter = egress_filter if egress_filter is not None else ''
 9348        '''
 9349         A filter applied to the routing logic to pin datasource to nodes.
 9350        '''
 9351        self.healthy = healthy if healthy is not None else False
 9352        '''
 9353         True if the datasource is reachable and the credentials are valid.
 9354        '''
 9355        self.hostname = hostname if hostname is not None else ''
 9356        self.id = id if id is not None else ''
 9357        '''
 9358         Unique identifier of the Resource.
 9359        '''
 9360        self.name = name if name is not None else ''
 9361        '''
 9362         Unique human-readable name of the Resource.
 9363        '''
 9364        self.password = password if password is not None else ''
 9365        self.port = port if port is not None else 0
 9366        self.port_override = port_override if port_override is not None else 0
 9367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9368        '''
 9369         ID of the secret store containing credentials for this resource, if any.
 9370        '''
 9371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9372        '''
 9373         Tags is a map of key, value pairs.
 9374        '''
 9375
 9376    def __repr__(self):
 9377        return '<sdm.Redis ' + \
 9378            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9379            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9380            'healthy: ' + repr(self.healthy) + ' ' +\
 9381            'hostname: ' + repr(self.hostname) + ' ' +\
 9382            'id: ' + repr(self.id) + ' ' +\
 9383            'name: ' + repr(self.name) + ' ' +\
 9384            'password: ' + repr(self.password) + ' ' +\
 9385            'port: ' + repr(self.port) + ' ' +\
 9386            'port_override: ' + repr(self.port_override) + ' ' +\
 9387            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9388            'tags: ' + repr(self.tags) + ' ' +\
 9389            '>'
 9390
 9391    def to_dict(self):
 9392        return {
 9393            'bind_interface': self.bind_interface,
 9394            'egress_filter': self.egress_filter,
 9395            'healthy': self.healthy,
 9396            'hostname': self.hostname,
 9397            'id': self.id,
 9398            'name': self.name,
 9399            'password': self.password,
 9400            'port': self.port,
 9401            'port_override': self.port_override,
 9402            'secret_store_id': self.secret_store_id,
 9403            'tags': self.tags,
 9404        }
 9405
 9406    @classmethod
 9407    def from_dict(cls, d):
 9408        return cls(
 9409            bind_interface=d.get('bind_interface'),
 9410            egress_filter=d.get('egress_filter'),
 9411            healthy=d.get('healthy'),
 9412            hostname=d.get('hostname'),
 9413            id=d.get('id'),
 9414            name=d.get('name'),
 9415            password=d.get('password'),
 9416            port=d.get('port'),
 9417            port_override=d.get('port_override'),
 9418            secret_store_id=d.get('secret_store_id'),
 9419            tags=d.get('tags'),
 9420        )
 9421
 9422
 9423class Redshift:
 9424    __slots__ = [
 9425        'bind_interface',
 9426        'database',
 9427        'egress_filter',
 9428        'healthy',
 9429        'hostname',
 9430        'id',
 9431        'name',
 9432        'override_database',
 9433        'password',
 9434        'port',
 9435        'port_override',
 9436        'secret_store_id',
 9437        'tags',
 9438        'username',
 9439    ]
 9440
 9441    def __init__(
 9442        self,
 9443        bind_interface=None,
 9444        database=None,
 9445        egress_filter=None,
 9446        healthy=None,
 9447        hostname=None,
 9448        id=None,
 9449        name=None,
 9450        override_database=None,
 9451        password=None,
 9452        port=None,
 9453        port_override=None,
 9454        secret_store_id=None,
 9455        tags=None,
 9456        username=None,
 9457    ):
 9458        self.bind_interface = bind_interface if bind_interface is not None else ''
 9459        '''
 9460         Bind interface
 9461        '''
 9462        self.database = database if database is not None else ''
 9463        self.egress_filter = egress_filter if egress_filter is not None else ''
 9464        '''
 9465         A filter applied to the routing logic to pin datasource to nodes.
 9466        '''
 9467        self.healthy = healthy if healthy is not None else False
 9468        '''
 9469         True if the datasource is reachable and the credentials are valid.
 9470        '''
 9471        self.hostname = hostname if hostname is not None else ''
 9472        self.id = id if id is not None else ''
 9473        '''
 9474         Unique identifier of the Resource.
 9475        '''
 9476        self.name = name if name is not None else ''
 9477        '''
 9478         Unique human-readable name of the Resource.
 9479        '''
 9480        self.override_database = override_database if override_database is not None else False
 9481        self.password = password if password is not None else ''
 9482        self.port = port if port is not None else 0
 9483        self.port_override = port_override if port_override is not None else 0
 9484        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9485        '''
 9486         ID of the secret store containing credentials for this resource, if any.
 9487        '''
 9488        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9489        '''
 9490         Tags is a map of key, value pairs.
 9491        '''
 9492        self.username = username if username is not None else ''
 9493
 9494    def __repr__(self):
 9495        return '<sdm.Redshift ' + \
 9496            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9497            'database: ' + repr(self.database) + ' ' +\
 9498            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9499            'healthy: ' + repr(self.healthy) + ' ' +\
 9500            'hostname: ' + repr(self.hostname) + ' ' +\
 9501            'id: ' + repr(self.id) + ' ' +\
 9502            'name: ' + repr(self.name) + ' ' +\
 9503            'override_database: ' + repr(self.override_database) + ' ' +\
 9504            'password: ' + repr(self.password) + ' ' +\
 9505            'port: ' + repr(self.port) + ' ' +\
 9506            'port_override: ' + repr(self.port_override) + ' ' +\
 9507            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9508            'tags: ' + repr(self.tags) + ' ' +\
 9509            'username: ' + repr(self.username) + ' ' +\
 9510            '>'
 9511
 9512    def to_dict(self):
 9513        return {
 9514            'bind_interface': self.bind_interface,
 9515            'database': self.database,
 9516            'egress_filter': self.egress_filter,
 9517            'healthy': self.healthy,
 9518            'hostname': self.hostname,
 9519            'id': self.id,
 9520            'name': self.name,
 9521            'override_database': self.override_database,
 9522            'password': self.password,
 9523            'port': self.port,
 9524            'port_override': self.port_override,
 9525            'secret_store_id': self.secret_store_id,
 9526            'tags': self.tags,
 9527            'username': self.username,
 9528        }
 9529
 9530    @classmethod
 9531    def from_dict(cls, d):
 9532        return cls(
 9533            bind_interface=d.get('bind_interface'),
 9534            database=d.get('database'),
 9535            egress_filter=d.get('egress_filter'),
 9536            healthy=d.get('healthy'),
 9537            hostname=d.get('hostname'),
 9538            id=d.get('id'),
 9539            name=d.get('name'),
 9540            override_database=d.get('override_database'),
 9541            password=d.get('password'),
 9542            port=d.get('port'),
 9543            port_override=d.get('port_override'),
 9544            secret_store_id=d.get('secret_store_id'),
 9545            tags=d.get('tags'),
 9546            username=d.get('username'),
 9547        )
 9548
 9549
 9550class Relay:
 9551    '''
 9552         Relay represents a StrongDM CLI installation running in relay mode.
 9553    '''
 9554    __slots__ = [
 9555        'gateway_filter',
 9556        'id',
 9557        'name',
 9558        'state',
 9559        'tags',
 9560    ]
 9561
 9562    def __init__(
 9563        self,
 9564        gateway_filter=None,
 9565        id=None,
 9566        name=None,
 9567        state=None,
 9568        tags=None,
 9569    ):
 9570        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9571        '''
 9572         GatewayFilter can be used to restrict the peering between relays and
 9573         gateways.
 9574        '''
 9575        self.id = id if id is not None else ''
 9576        '''
 9577         Unique identifier of the Relay.
 9578        '''
 9579        self.name = name if name is not None else ''
 9580        '''
 9581         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9582        '''
 9583        self.state = state if state is not None else ''
 9584        '''
 9585         The current state of the relay. One of: "new", "verifying_restart",
 9586         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9587         "unknown".
 9588        '''
 9589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9590        '''
 9591         Tags is a map of key, value pairs.
 9592        '''
 9593
 9594    def __repr__(self):
 9595        return '<sdm.Relay ' + \
 9596            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9597            'id: ' + repr(self.id) + ' ' +\
 9598            'name: ' + repr(self.name) + ' ' +\
 9599            'state: ' + repr(self.state) + ' ' +\
 9600            'tags: ' + repr(self.tags) + ' ' +\
 9601            '>'
 9602
 9603    def to_dict(self):
 9604        return {
 9605            'gateway_filter': self.gateway_filter,
 9606            'id': self.id,
 9607            'name': self.name,
 9608            'state': self.state,
 9609            'tags': self.tags,
 9610        }
 9611
 9612    @classmethod
 9613    def from_dict(cls, d):
 9614        return cls(
 9615            gateway_filter=d.get('gateway_filter'),
 9616            id=d.get('id'),
 9617            name=d.get('name'),
 9618            state=d.get('state'),
 9619            tags=d.get('tags'),
 9620        )
 9621
 9622
 9623class RemoteIdentity:
 9624    '''
 9625         RemoteIdentities define the username to be used for a specific account
 9626     when connecting to a remote resource using that group.
 9627    '''
 9628    __slots__ = [
 9629        'account_id',
 9630        'id',
 9631        'remote_identity_group_id',
 9632        'username',
 9633    ]
 9634
 9635    def __init__(
 9636        self,
 9637        account_id=None,
 9638        id=None,
 9639        remote_identity_group_id=None,
 9640        username=None,
 9641    ):
 9642        self.account_id = account_id if account_id is not None else ''
 9643        '''
 9644         The account for this remote identity.
 9645        '''
 9646        self.id = id if id is not None else ''
 9647        '''
 9648         Unique identifier of the RemoteIdentity.
 9649        '''
 9650        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9651        '''
 9652         The remote identity group.
 9653        '''
 9654        self.username = username if username is not None else ''
 9655        '''
 9656         The username to be used as the remote identity for this account.
 9657        '''
 9658
 9659    def __repr__(self):
 9660        return '<sdm.RemoteIdentity ' + \
 9661            'account_id: ' + repr(self.account_id) + ' ' +\
 9662            'id: ' + repr(self.id) + ' ' +\
 9663            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9664            'username: ' + repr(self.username) + ' ' +\
 9665            '>'
 9666
 9667    def to_dict(self):
 9668        return {
 9669            'account_id': self.account_id,
 9670            'id': self.id,
 9671            'remote_identity_group_id': self.remote_identity_group_id,
 9672            'username': self.username,
 9673        }
 9674
 9675    @classmethod
 9676    def from_dict(cls, d):
 9677        return cls(
 9678            account_id=d.get('account_id'),
 9679            id=d.get('id'),
 9680            remote_identity_group_id=d.get('remote_identity_group_id'),
 9681            username=d.get('username'),
 9682        )
 9683
 9684
 9685class RemoteIdentityCreateResponse:
 9686    '''
 9687         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9688    '''
 9689    __slots__ = [
 9690        'meta',
 9691        'rate_limit',
 9692        'remote_identity',
 9693    ]
 9694
 9695    def __init__(
 9696        self,
 9697        meta=None,
 9698        rate_limit=None,
 9699        remote_identity=None,
 9700    ):
 9701        self.meta = meta if meta is not None else None
 9702        '''
 9703         Reserved for future use.
 9704        '''
 9705        self.rate_limit = rate_limit if rate_limit is not None else None
 9706        '''
 9707         Rate limit information.
 9708        '''
 9709        self.remote_identity = remote_identity if remote_identity is not None else None
 9710        '''
 9711         The created RemoteIdentity.
 9712        '''
 9713
 9714    def __repr__(self):
 9715        return '<sdm.RemoteIdentityCreateResponse ' + \
 9716            'meta: ' + repr(self.meta) + ' ' +\
 9717            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9718            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9719            '>'
 9720
 9721    def to_dict(self):
 9722        return {
 9723            'meta': self.meta,
 9724            'rate_limit': self.rate_limit,
 9725            'remote_identity': self.remote_identity,
 9726        }
 9727
 9728    @classmethod
 9729    def from_dict(cls, d):
 9730        return cls(
 9731            meta=d.get('meta'),
 9732            rate_limit=d.get('rate_limit'),
 9733            remote_identity=d.get('remote_identity'),
 9734        )
 9735
 9736
 9737class RemoteIdentityDeleteResponse:
 9738    '''
 9739         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9740    '''
 9741    __slots__ = [
 9742        'meta',
 9743        'rate_limit',
 9744    ]
 9745
 9746    def __init__(
 9747        self,
 9748        meta=None,
 9749        rate_limit=None,
 9750    ):
 9751        self.meta = meta if meta is not None else None
 9752        '''
 9753         Reserved for future use.
 9754        '''
 9755        self.rate_limit = rate_limit if rate_limit is not None else None
 9756        '''
 9757         Rate limit information.
 9758        '''
 9759
 9760    def __repr__(self):
 9761        return '<sdm.RemoteIdentityDeleteResponse ' + \
 9762            'meta: ' + repr(self.meta) + ' ' +\
 9763            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9764            '>'
 9765
 9766    def to_dict(self):
 9767        return {
 9768            'meta': self.meta,
 9769            'rate_limit': self.rate_limit,
 9770        }
 9771
 9772    @classmethod
 9773    def from_dict(cls, d):
 9774        return cls(
 9775            meta=d.get('meta'),
 9776            rate_limit=d.get('rate_limit'),
 9777        )
 9778
 9779
 9780class RemoteIdentityGetResponse:
 9781    '''
 9782         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9783    '''
 9784    __slots__ = [
 9785        'meta',
 9786        'rate_limit',
 9787        'remote_identity',
 9788    ]
 9789
 9790    def __init__(
 9791        self,
 9792        meta=None,
 9793        rate_limit=None,
 9794        remote_identity=None,
 9795    ):
 9796        self.meta = meta if meta is not None else None
 9797        '''
 9798         Reserved for future use.
 9799        '''
 9800        self.rate_limit = rate_limit if rate_limit is not None else None
 9801        '''
 9802         Rate limit information.
 9803        '''
 9804        self.remote_identity = remote_identity if remote_identity is not None else None
 9805        '''
 9806         The requested RemoteIdentity.
 9807        '''
 9808
 9809    def __repr__(self):
 9810        return '<sdm.RemoteIdentityGetResponse ' + \
 9811            'meta: ' + repr(self.meta) + ' ' +\
 9812            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9813            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9814            '>'
 9815
 9816    def to_dict(self):
 9817        return {
 9818            'meta': self.meta,
 9819            'rate_limit': self.rate_limit,
 9820            'remote_identity': self.remote_identity,
 9821        }
 9822
 9823    @classmethod
 9824    def from_dict(cls, d):
 9825        return cls(
 9826            meta=d.get('meta'),
 9827            rate_limit=d.get('rate_limit'),
 9828            remote_identity=d.get('remote_identity'),
 9829        )
 9830
 9831
 9832class RemoteIdentityGroup:
 9833    '''
 9834         A RemoteIdentityGroup defines a group of remote identities.
 9835    '''
 9836    __slots__ = [
 9837        'id',
 9838        'name',
 9839    ]
 9840
 9841    def __init__(
 9842        self,
 9843        id=None,
 9844        name=None,
 9845    ):
 9846        self.id = id if id is not None else ''
 9847        '''
 9848         Unique identifier of the RemoteIdentityGroup.
 9849        '''
 9850        self.name = name if name is not None else ''
 9851        '''
 9852         Unique human-readable name of the RemoteIdentityGroup.
 9853        '''
 9854
 9855    def __repr__(self):
 9856        return '<sdm.RemoteIdentityGroup ' + \
 9857            'id: ' + repr(self.id) + ' ' +\
 9858            'name: ' + repr(self.name) + ' ' +\
 9859            '>'
 9860
 9861    def to_dict(self):
 9862        return {
 9863            'id': self.id,
 9864            'name': self.name,
 9865        }
 9866
 9867    @classmethod
 9868    def from_dict(cls, d):
 9869        return cls(
 9870            id=d.get('id'),
 9871            name=d.get('name'),
 9872        )
 9873
 9874
 9875class RemoteIdentityGroupGetResponse:
 9876    '''
 9877         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
 9878    '''
 9879    __slots__ = [
 9880        'meta',
 9881        'rate_limit',
 9882        'remote_identity_group',
 9883    ]
 9884
 9885    def __init__(
 9886        self,
 9887        meta=None,
 9888        rate_limit=None,
 9889        remote_identity_group=None,
 9890    ):
 9891        self.meta = meta if meta is not None else None
 9892        '''
 9893         Reserved for future use.
 9894        '''
 9895        self.rate_limit = rate_limit if rate_limit is not None else None
 9896        '''
 9897         Rate limit information.
 9898        '''
 9899        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
 9900        '''
 9901         The requested RemoteIdentityGroup.
 9902        '''
 9903
 9904    def __repr__(self):
 9905        return '<sdm.RemoteIdentityGroupGetResponse ' + \
 9906            'meta: ' + repr(self.meta) + ' ' +\
 9907            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9908            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
 9909            '>'
 9910
 9911    def to_dict(self):
 9912        return {
 9913            'meta': self.meta,
 9914            'rate_limit': self.rate_limit,
 9915            'remote_identity_group': self.remote_identity_group,
 9916        }
 9917
 9918    @classmethod
 9919    def from_dict(cls, d):
 9920        return cls(
 9921            meta=d.get('meta'),
 9922            rate_limit=d.get('rate_limit'),
 9923            remote_identity_group=d.get('remote_identity_group'),
 9924        )
 9925
 9926
 9927class RemoteIdentityUpdateResponse:
 9928    '''
 9929         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
 9930     a RemoteIdentityUpdateRequest.
 9931    '''
 9932    __slots__ = [
 9933        'meta',
 9934        'rate_limit',
 9935        'remote_identity',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        meta=None,
 9941        rate_limit=None,
 9942        remote_identity=None,
 9943    ):
 9944        self.meta = meta if meta is not None else None
 9945        '''
 9946         Reserved for future use.
 9947        '''
 9948        self.rate_limit = rate_limit if rate_limit is not None else None
 9949        '''
 9950         Rate limit information.
 9951        '''
 9952        self.remote_identity = remote_identity if remote_identity is not None else None
 9953        '''
 9954         The updated RemoteIdentity.
 9955        '''
 9956
 9957    def __repr__(self):
 9958        return '<sdm.RemoteIdentityUpdateResponse ' + \
 9959            'meta: ' + repr(self.meta) + ' ' +\
 9960            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9961            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9962            '>'
 9963
 9964    def to_dict(self):
 9965        return {
 9966            'meta': self.meta,
 9967            'rate_limit': self.rate_limit,
 9968            'remote_identity': self.remote_identity,
 9969        }
 9970
 9971    @classmethod
 9972    def from_dict(cls, d):
 9973        return cls(
 9974            meta=d.get('meta'),
 9975            rate_limit=d.get('rate_limit'),
 9976            remote_identity=d.get('remote_identity'),
 9977        )
 9978
 9979
 9980class ResourceCreateResponse:
 9981    '''
 9982         ResourceCreateResponse reports how the Resources were created in the system.
 9983    '''
 9984    __slots__ = [
 9985        'meta',
 9986        'rate_limit',
 9987        'resource',
 9988    ]
 9989
 9990    def __init__(
 9991        self,
 9992        meta=None,
 9993        rate_limit=None,
 9994        resource=None,
 9995    ):
 9996        self.meta = meta if meta is not None else None
 9997        '''
 9998         Reserved for future use.
 9999        '''
10000        self.rate_limit = rate_limit if rate_limit is not None else None
10001        '''
10002         Rate limit information.
10003        '''
10004        self.resource = resource if resource is not None else None
10005        '''
10006         The created Resource.
10007        '''
10008
10009    def __repr__(self):
10010        return '<sdm.ResourceCreateResponse ' + \
10011            'meta: ' + repr(self.meta) + ' ' +\
10012            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10013            'resource: ' + repr(self.resource) + ' ' +\
10014            '>'
10015
10016    def to_dict(self):
10017        return {
10018            'meta': self.meta,
10019            'rate_limit': self.rate_limit,
10020            'resource': self.resource,
10021        }
10022
10023    @classmethod
10024    def from_dict(cls, d):
10025        return cls(
10026            meta=d.get('meta'),
10027            rate_limit=d.get('rate_limit'),
10028            resource=d.get('resource'),
10029        )
10030
10031
10032class ResourceDeleteResponse:
10033    '''
10034         ResourceDeleteResponse returns information about a Resource that was deleted.
10035    '''
10036    __slots__ = [
10037        'meta',
10038        'rate_limit',
10039    ]
10040
10041    def __init__(
10042        self,
10043        meta=None,
10044        rate_limit=None,
10045    ):
10046        self.meta = meta if meta is not None else None
10047        '''
10048         Reserved for future use.
10049        '''
10050        self.rate_limit = rate_limit if rate_limit is not None else None
10051        '''
10052         Rate limit information.
10053        '''
10054
10055    def __repr__(self):
10056        return '<sdm.ResourceDeleteResponse ' + \
10057            'meta: ' + repr(self.meta) + ' ' +\
10058            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10059            '>'
10060
10061    def to_dict(self):
10062        return {
10063            'meta': self.meta,
10064            'rate_limit': self.rate_limit,
10065        }
10066
10067    @classmethod
10068    def from_dict(cls, d):
10069        return cls(
10070            meta=d.get('meta'),
10071            rate_limit=d.get('rate_limit'),
10072        )
10073
10074
10075class ResourceGetResponse:
10076    '''
10077         ResourceGetResponse returns a requested Resource.
10078    '''
10079    __slots__ = [
10080        'meta',
10081        'rate_limit',
10082        'resource',
10083    ]
10084
10085    def __init__(
10086        self,
10087        meta=None,
10088        rate_limit=None,
10089        resource=None,
10090    ):
10091        self.meta = meta if meta is not None else None
10092        '''
10093         Reserved for future use.
10094        '''
10095        self.rate_limit = rate_limit if rate_limit is not None else None
10096        '''
10097         Rate limit information.
10098        '''
10099        self.resource = resource if resource is not None else None
10100        '''
10101         The requested Resource.
10102        '''
10103
10104    def __repr__(self):
10105        return '<sdm.ResourceGetResponse ' + \
10106            'meta: ' + repr(self.meta) + ' ' +\
10107            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10108            'resource: ' + repr(self.resource) + ' ' +\
10109            '>'
10110
10111    def to_dict(self):
10112        return {
10113            'meta': self.meta,
10114            'rate_limit': self.rate_limit,
10115            'resource': self.resource,
10116        }
10117
10118    @classmethod
10119    def from_dict(cls, d):
10120        return cls(
10121            meta=d.get('meta'),
10122            rate_limit=d.get('rate_limit'),
10123            resource=d.get('resource'),
10124        )
10125
10126
10127class ResourceUpdateResponse:
10128    '''
10129         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10130     a ResourceUpdateRequest.
10131    '''
10132    __slots__ = [
10133        'meta',
10134        'rate_limit',
10135        'resource',
10136    ]
10137
10138    def __init__(
10139        self,
10140        meta=None,
10141        rate_limit=None,
10142        resource=None,
10143    ):
10144        self.meta = meta if meta is not None else None
10145        '''
10146         Reserved for future use.
10147        '''
10148        self.rate_limit = rate_limit if rate_limit is not None else None
10149        '''
10150         Rate limit information.
10151        '''
10152        self.resource = resource if resource is not None else None
10153        '''
10154         The updated Resource.
10155        '''
10156
10157    def __repr__(self):
10158        return '<sdm.ResourceUpdateResponse ' + \
10159            'meta: ' + repr(self.meta) + ' ' +\
10160            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10161            'resource: ' + repr(self.resource) + ' ' +\
10162            '>'
10163
10164    def to_dict(self):
10165        return {
10166            'meta': self.meta,
10167            'rate_limit': self.rate_limit,
10168            'resource': self.resource,
10169        }
10170
10171    @classmethod
10172    def from_dict(cls, d):
10173        return cls(
10174            meta=d.get('meta'),
10175            rate_limit=d.get('rate_limit'),
10176            resource=d.get('resource'),
10177        )
10178
10179
10180class Role:
10181    '''
10182         A Role has a list of access rules which determine which Resources the members
10183     of the Role have access to. An Account can be a member of multiple Roles via
10184     AccountAttachments.
10185    '''
10186    __slots__ = [
10187        'access_rules',
10188        'id',
10189        'name',
10190        'tags',
10191    ]
10192
10193    def __init__(
10194        self,
10195        access_rules=None,
10196        id=None,
10197        name=None,
10198        tags=None,
10199    ):
10200        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10201        )
10202        '''
10203         AccessRules is a list of access rules defining the resources this Role has access to.
10204        '''
10205        self.id = id if id is not None else ''
10206        '''
10207         Unique identifier of the Role.
10208        '''
10209        self.name = name if name is not None else ''
10210        '''
10211         Unique human-readable name of the Role.
10212        '''
10213        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10214        '''
10215         Tags is a map of key, value pairs.
10216        '''
10217
10218    def __repr__(self):
10219        return '<sdm.Role ' + \
10220            'access_rules: ' + repr(self.access_rules) + ' ' +\
10221            'id: ' + repr(self.id) + ' ' +\
10222            'name: ' + repr(self.name) + ' ' +\
10223            'tags: ' + repr(self.tags) + ' ' +\
10224            '>'
10225
10226    def to_dict(self):
10227        return {
10228            'access_rules': self.access_rules,
10229            'id': self.id,
10230            'name': self.name,
10231            'tags': self.tags,
10232        }
10233
10234    @classmethod
10235    def from_dict(cls, d):
10236        return cls(
10237            access_rules=d.get('access_rules'),
10238            id=d.get('id'),
10239            name=d.get('name'),
10240            tags=d.get('tags'),
10241        )
10242
10243
10244class RoleCreateResponse:
10245    '''
10246         RoleCreateResponse reports how the Roles were created in the system. It can
10247     communicate partial successes or failures.
10248    '''
10249    __slots__ = [
10250        'meta',
10251        'rate_limit',
10252        'role',
10253    ]
10254
10255    def __init__(
10256        self,
10257        meta=None,
10258        rate_limit=None,
10259        role=None,
10260    ):
10261        self.meta = meta if meta is not None else None
10262        '''
10263         Reserved for future use.
10264        '''
10265        self.rate_limit = rate_limit if rate_limit is not None else None
10266        '''
10267         Rate limit information.
10268        '''
10269        self.role = role if role is not None else None
10270        '''
10271         The created Role.
10272        '''
10273
10274    def __repr__(self):
10275        return '<sdm.RoleCreateResponse ' + \
10276            'meta: ' + repr(self.meta) + ' ' +\
10277            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10278            'role: ' + repr(self.role) + ' ' +\
10279            '>'
10280
10281    def to_dict(self):
10282        return {
10283            'meta': self.meta,
10284            'rate_limit': self.rate_limit,
10285            'role': self.role,
10286        }
10287
10288    @classmethod
10289    def from_dict(cls, d):
10290        return cls(
10291            meta=d.get('meta'),
10292            rate_limit=d.get('rate_limit'),
10293            role=d.get('role'),
10294        )
10295
10296
10297class RoleDeleteResponse:
10298    '''
10299         RoleDeleteResponse returns information about a Role that was deleted.
10300    '''
10301    __slots__ = [
10302        'meta',
10303        'rate_limit',
10304    ]
10305
10306    def __init__(
10307        self,
10308        meta=None,
10309        rate_limit=None,
10310    ):
10311        self.meta = meta if meta is not None else None
10312        '''
10313         Reserved for future use.
10314        '''
10315        self.rate_limit = rate_limit if rate_limit is not None else None
10316        '''
10317         Rate limit information.
10318        '''
10319
10320    def __repr__(self):
10321        return '<sdm.RoleDeleteResponse ' + \
10322            'meta: ' + repr(self.meta) + ' ' +\
10323            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10324            '>'
10325
10326    def to_dict(self):
10327        return {
10328            'meta': self.meta,
10329            'rate_limit': self.rate_limit,
10330        }
10331
10332    @classmethod
10333    def from_dict(cls, d):
10334        return cls(
10335            meta=d.get('meta'),
10336            rate_limit=d.get('rate_limit'),
10337        )
10338
10339
10340class RoleGetResponse:
10341    '''
10342         RoleGetResponse returns a requested Role.
10343    '''
10344    __slots__ = [
10345        'meta',
10346        'rate_limit',
10347        'role',
10348    ]
10349
10350    def __init__(
10351        self,
10352        meta=None,
10353        rate_limit=None,
10354        role=None,
10355    ):
10356        self.meta = meta if meta is not None else None
10357        '''
10358         Reserved for future use.
10359        '''
10360        self.rate_limit = rate_limit if rate_limit is not None else None
10361        '''
10362         Rate limit information.
10363        '''
10364        self.role = role if role is not None else None
10365        '''
10366         The requested Role.
10367        '''
10368
10369    def __repr__(self):
10370        return '<sdm.RoleGetResponse ' + \
10371            'meta: ' + repr(self.meta) + ' ' +\
10372            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10373            'role: ' + repr(self.role) + ' ' +\
10374            '>'
10375
10376    def to_dict(self):
10377        return {
10378            'meta': self.meta,
10379            'rate_limit': self.rate_limit,
10380            'role': self.role,
10381        }
10382
10383    @classmethod
10384    def from_dict(cls, d):
10385        return cls(
10386            meta=d.get('meta'),
10387            rate_limit=d.get('rate_limit'),
10388            role=d.get('role'),
10389        )
10390
10391
10392class RoleUpdateResponse:
10393    '''
10394         RoleUpdateResponse returns the fields of a Role after it has been updated by
10395     a RoleUpdateRequest.
10396    '''
10397    __slots__ = [
10398        'meta',
10399        'rate_limit',
10400        'role',
10401    ]
10402
10403    def __init__(
10404        self,
10405        meta=None,
10406        rate_limit=None,
10407        role=None,
10408    ):
10409        self.meta = meta if meta is not None else None
10410        '''
10411         Reserved for future use.
10412        '''
10413        self.rate_limit = rate_limit if rate_limit is not None else None
10414        '''
10415         Rate limit information.
10416        '''
10417        self.role = role if role is not None else None
10418        '''
10419         The updated Role.
10420        '''
10421
10422    def __repr__(self):
10423        return '<sdm.RoleUpdateResponse ' + \
10424            'meta: ' + repr(self.meta) + ' ' +\
10425            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10426            'role: ' + repr(self.role) + ' ' +\
10427            '>'
10428
10429    def to_dict(self):
10430        return {
10431            'meta': self.meta,
10432            'rate_limit': self.rate_limit,
10433            'role': self.role,
10434        }
10435
10436    @classmethod
10437    def from_dict(cls, d):
10438        return cls(
10439            meta=d.get('meta'),
10440            rate_limit=d.get('rate_limit'),
10441            role=d.get('role'),
10442        )
10443
10444
10445class SQLServer:
10446    __slots__ = [
10447        'bind_interface',
10448        'database',
10449        'egress_filter',
10450        'healthy',
10451        'hostname',
10452        'id',
10453        'name',
10454        'override_database',
10455        'password',
10456        'port',
10457        'port_override',
10458        'schema',
10459        'secret_store_id',
10460        'tags',
10461        'username',
10462    ]
10463
10464    def __init__(
10465        self,
10466        bind_interface=None,
10467        database=None,
10468        egress_filter=None,
10469        healthy=None,
10470        hostname=None,
10471        id=None,
10472        name=None,
10473        override_database=None,
10474        password=None,
10475        port=None,
10476        port_override=None,
10477        schema=None,
10478        secret_store_id=None,
10479        tags=None,
10480        username=None,
10481    ):
10482        self.bind_interface = bind_interface if bind_interface is not None else ''
10483        '''
10484         Bind interface
10485        '''
10486        self.database = database if database is not None else ''
10487        self.egress_filter = egress_filter if egress_filter is not None else ''
10488        '''
10489         A filter applied to the routing logic to pin datasource to nodes.
10490        '''
10491        self.healthy = healthy if healthy is not None else False
10492        '''
10493         True if the datasource is reachable and the credentials are valid.
10494        '''
10495        self.hostname = hostname if hostname is not None else ''
10496        self.id = id if id is not None else ''
10497        '''
10498         Unique identifier of the Resource.
10499        '''
10500        self.name = name if name is not None else ''
10501        '''
10502         Unique human-readable name of the Resource.
10503        '''
10504        self.override_database = override_database if override_database is not None else False
10505        self.password = password if password is not None else ''
10506        self.port = port if port is not None else 0
10507        self.port_override = port_override if port_override is not None else 0
10508        self.schema = schema if schema is not None else ''
10509        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10510        '''
10511         ID of the secret store containing credentials for this resource, if any.
10512        '''
10513        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10514        '''
10515         Tags is a map of key, value pairs.
10516        '''
10517        self.username = username if username is not None else ''
10518
10519    def __repr__(self):
10520        return '<sdm.SQLServer ' + \
10521            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10522            'database: ' + repr(self.database) + ' ' +\
10523            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10524            'healthy: ' + repr(self.healthy) + ' ' +\
10525            'hostname: ' + repr(self.hostname) + ' ' +\
10526            'id: ' + repr(self.id) + ' ' +\
10527            'name: ' + repr(self.name) + ' ' +\
10528            'override_database: ' + repr(self.override_database) + ' ' +\
10529            'password: ' + repr(self.password) + ' ' +\
10530            'port: ' + repr(self.port) + ' ' +\
10531            'port_override: ' + repr(self.port_override) + ' ' +\
10532            'schema: ' + repr(self.schema) + ' ' +\
10533            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10534            'tags: ' + repr(self.tags) + ' ' +\
10535            'username: ' + repr(self.username) + ' ' +\
10536            '>'
10537
10538    def to_dict(self):
10539        return {
10540            'bind_interface': self.bind_interface,
10541            'database': self.database,
10542            'egress_filter': self.egress_filter,
10543            'healthy': self.healthy,
10544            'hostname': self.hostname,
10545            'id': self.id,
10546            'name': self.name,
10547            'override_database': self.override_database,
10548            'password': self.password,
10549            'port': self.port,
10550            'port_override': self.port_override,
10551            'schema': self.schema,
10552            'secret_store_id': self.secret_store_id,
10553            'tags': self.tags,
10554            'username': self.username,
10555        }
10556
10557    @classmethod
10558    def from_dict(cls, d):
10559        return cls(
10560            bind_interface=d.get('bind_interface'),
10561            database=d.get('database'),
10562            egress_filter=d.get('egress_filter'),
10563            healthy=d.get('healthy'),
10564            hostname=d.get('hostname'),
10565            id=d.get('id'),
10566            name=d.get('name'),
10567            override_database=d.get('override_database'),
10568            password=d.get('password'),
10569            port=d.get('port'),
10570            port_override=d.get('port_override'),
10571            schema=d.get('schema'),
10572            secret_store_id=d.get('secret_store_id'),
10573            tags=d.get('tags'),
10574            username=d.get('username'),
10575        )
10576
10577
10578class SSH:
10579    __slots__ = [
10580        'allow_deprecated_key_exchanges',
10581        'bind_interface',
10582        'egress_filter',
10583        'healthy',
10584        'hostname',
10585        'id',
10586        'key_type',
10587        'name',
10588        'port',
10589        'port_forwarding',
10590        'port_override',
10591        'public_key',
10592        'secret_store_id',
10593        'tags',
10594        'username',
10595    ]
10596
10597    def __init__(
10598        self,
10599        allow_deprecated_key_exchanges=None,
10600        bind_interface=None,
10601        egress_filter=None,
10602        healthy=None,
10603        hostname=None,
10604        id=None,
10605        key_type=None,
10606        name=None,
10607        port=None,
10608        port_forwarding=None,
10609        port_override=None,
10610        public_key=None,
10611        secret_store_id=None,
10612        tags=None,
10613        username=None,
10614    ):
10615        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10616        self.bind_interface = bind_interface if bind_interface is not None else ''
10617        '''
10618         Bind interface
10619        '''
10620        self.egress_filter = egress_filter if egress_filter is not None else ''
10621        '''
10622         A filter applied to the routing logic to pin datasource to nodes.
10623        '''
10624        self.healthy = healthy if healthy is not None else False
10625        '''
10626         True if the datasource is reachable and the credentials are valid.
10627        '''
10628        self.hostname = hostname if hostname is not None else ''
10629        self.id = id if id is not None else ''
10630        '''
10631         Unique identifier of the Resource.
10632        '''
10633        self.key_type = key_type if key_type is not None else ''
10634        self.name = name if name is not None else ''
10635        '''
10636         Unique human-readable name of the Resource.
10637        '''
10638        self.port = port if port is not None else 0
10639        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10640        self.port_override = port_override if port_override is not None else 0
10641        self.public_key = public_key if public_key is not None else ''
10642        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10643        '''
10644         ID of the secret store containing credentials for this resource, if any.
10645        '''
10646        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10647        '''
10648         Tags is a map of key, value pairs.
10649        '''
10650        self.username = username if username is not None else ''
10651
10652    def __repr__(self):
10653        return '<sdm.SSH ' + \
10654            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10655            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10656            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10657            'healthy: ' + repr(self.healthy) + ' ' +\
10658            'hostname: ' + repr(self.hostname) + ' ' +\
10659            'id: ' + repr(self.id) + ' ' +\
10660            'key_type: ' + repr(self.key_type) + ' ' +\
10661            'name: ' + repr(self.name) + ' ' +\
10662            'port: ' + repr(self.port) + ' ' +\
10663            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10664            'port_override: ' + repr(self.port_override) + ' ' +\
10665            'public_key: ' + repr(self.public_key) + ' ' +\
10666            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10667            'tags: ' + repr(self.tags) + ' ' +\
10668            'username: ' + repr(self.username) + ' ' +\
10669            '>'
10670
10671    def to_dict(self):
10672        return {
10673            'allow_deprecated_key_exchanges':
10674            self.allow_deprecated_key_exchanges,
10675            'bind_interface': self.bind_interface,
10676            'egress_filter': self.egress_filter,
10677            'healthy': self.healthy,
10678            'hostname': self.hostname,
10679            'id': self.id,
10680            'key_type': self.key_type,
10681            'name': self.name,
10682            'port': self.port,
10683            'port_forwarding': self.port_forwarding,
10684            'port_override': self.port_override,
10685            'public_key': self.public_key,
10686            'secret_store_id': self.secret_store_id,
10687            'tags': self.tags,
10688            'username': self.username,
10689        }
10690
10691    @classmethod
10692    def from_dict(cls, d):
10693        return cls(
10694            allow_deprecated_key_exchanges=d.get(
10695                'allow_deprecated_key_exchanges'),
10696            bind_interface=d.get('bind_interface'),
10697            egress_filter=d.get('egress_filter'),
10698            healthy=d.get('healthy'),
10699            hostname=d.get('hostname'),
10700            id=d.get('id'),
10701            key_type=d.get('key_type'),
10702            name=d.get('name'),
10703            port=d.get('port'),
10704            port_forwarding=d.get('port_forwarding'),
10705            port_override=d.get('port_override'),
10706            public_key=d.get('public_key'),
10707            secret_store_id=d.get('secret_store_id'),
10708            tags=d.get('tags'),
10709            username=d.get('username'),
10710        )
10711
10712
10713class SSHCert:
10714    __slots__ = [
10715        'allow_deprecated_key_exchanges',
10716        'bind_interface',
10717        'egress_filter',
10718        'healthy',
10719        'hostname',
10720        'id',
10721        'key_type',
10722        'name',
10723        'port',
10724        'port_forwarding',
10725        'port_override',
10726        'remote_identity_group_id',
10727        'remote_identity_healthcheck_username',
10728        'secret_store_id',
10729        'tags',
10730        'username',
10731    ]
10732
10733    def __init__(
10734        self,
10735        allow_deprecated_key_exchanges=None,
10736        bind_interface=None,
10737        egress_filter=None,
10738        healthy=None,
10739        hostname=None,
10740        id=None,
10741        key_type=None,
10742        name=None,
10743        port=None,
10744        port_forwarding=None,
10745        port_override=None,
10746        remote_identity_group_id=None,
10747        remote_identity_healthcheck_username=None,
10748        secret_store_id=None,
10749        tags=None,
10750        username=None,
10751    ):
10752        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10753        self.bind_interface = bind_interface if bind_interface is not None else ''
10754        '''
10755         Bind interface
10756        '''
10757        self.egress_filter = egress_filter if egress_filter is not None else ''
10758        '''
10759         A filter applied to the routing logic to pin datasource to nodes.
10760        '''
10761        self.healthy = healthy if healthy is not None else False
10762        '''
10763         True if the datasource is reachable and the credentials are valid.
10764        '''
10765        self.hostname = hostname if hostname is not None else ''
10766        self.id = id if id is not None else ''
10767        '''
10768         Unique identifier of the Resource.
10769        '''
10770        self.key_type = key_type if key_type is not None else ''
10771        self.name = name if name is not None else ''
10772        '''
10773         Unique human-readable name of the Resource.
10774        '''
10775        self.port = port if port is not None else 0
10776        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10777        self.port_override = port_override if port_override is not None else 0
10778        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10779        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10780        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10781        '''
10782         ID of the secret store containing credentials for this resource, if any.
10783        '''
10784        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10785        '''
10786         Tags is a map of key, value pairs.
10787        '''
10788        self.username = username if username is not None else ''
10789
10790    def __repr__(self):
10791        return '<sdm.SSHCert ' + \
10792            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10793            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10794            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10795            'healthy: ' + repr(self.healthy) + ' ' +\
10796            'hostname: ' + repr(self.hostname) + ' ' +\
10797            'id: ' + repr(self.id) + ' ' +\
10798            'key_type: ' + repr(self.key_type) + ' ' +\
10799            'name: ' + repr(self.name) + ' ' +\
10800            'port: ' + repr(self.port) + ' ' +\
10801            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10802            'port_override: ' + repr(self.port_override) + ' ' +\
10803            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10804            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10805            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10806            'tags: ' + repr(self.tags) + ' ' +\
10807            'username: ' + repr(self.username) + ' ' +\
10808            '>'
10809
10810    def to_dict(self):
10811        return {
10812            'allow_deprecated_key_exchanges':
10813            self.allow_deprecated_key_exchanges,
10814            'bind_interface': self.bind_interface,
10815            'egress_filter': self.egress_filter,
10816            'healthy': self.healthy,
10817            'hostname': self.hostname,
10818            'id': self.id,
10819            'key_type': self.key_type,
10820            'name': self.name,
10821            'port': self.port,
10822            'port_forwarding': self.port_forwarding,
10823            'port_override': self.port_override,
10824            'remote_identity_group_id': self.remote_identity_group_id,
10825            'remote_identity_healthcheck_username':
10826            self.remote_identity_healthcheck_username,
10827            'secret_store_id': self.secret_store_id,
10828            'tags': self.tags,
10829            'username': self.username,
10830        }
10831
10832    @classmethod
10833    def from_dict(cls, d):
10834        return cls(
10835            allow_deprecated_key_exchanges=d.get(
10836                'allow_deprecated_key_exchanges'),
10837            bind_interface=d.get('bind_interface'),
10838            egress_filter=d.get('egress_filter'),
10839            healthy=d.get('healthy'),
10840            hostname=d.get('hostname'),
10841            id=d.get('id'),
10842            key_type=d.get('key_type'),
10843            name=d.get('name'),
10844            port=d.get('port'),
10845            port_forwarding=d.get('port_forwarding'),
10846            port_override=d.get('port_override'),
10847            remote_identity_group_id=d.get('remote_identity_group_id'),
10848            remote_identity_healthcheck_username=d.get(
10849                'remote_identity_healthcheck_username'),
10850            secret_store_id=d.get('secret_store_id'),
10851            tags=d.get('tags'),
10852            username=d.get('username'),
10853        )
10854
10855
10856class SSHCustomerKey:
10857    __slots__ = [
10858        'allow_deprecated_key_exchanges',
10859        'bind_interface',
10860        'egress_filter',
10861        'healthy',
10862        'hostname',
10863        'id',
10864        'name',
10865        'port',
10866        'port_forwarding',
10867        'port_override',
10868        'private_key',
10869        'secret_store_id',
10870        'tags',
10871        'username',
10872    ]
10873
10874    def __init__(
10875        self,
10876        allow_deprecated_key_exchanges=None,
10877        bind_interface=None,
10878        egress_filter=None,
10879        healthy=None,
10880        hostname=None,
10881        id=None,
10882        name=None,
10883        port=None,
10884        port_forwarding=None,
10885        port_override=None,
10886        private_key=None,
10887        secret_store_id=None,
10888        tags=None,
10889        username=None,
10890    ):
10891        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10892        self.bind_interface = bind_interface if bind_interface is not None else ''
10893        '''
10894         Bind interface
10895        '''
10896        self.egress_filter = egress_filter if egress_filter is not None else ''
10897        '''
10898         A filter applied to the routing logic to pin datasource to nodes.
10899        '''
10900        self.healthy = healthy if healthy is not None else False
10901        '''
10902         True if the datasource is reachable and the credentials are valid.
10903        '''
10904        self.hostname = hostname if hostname is not None else ''
10905        self.id = id if id is not None else ''
10906        '''
10907         Unique identifier of the Resource.
10908        '''
10909        self.name = name if name is not None else ''
10910        '''
10911         Unique human-readable name of the Resource.
10912        '''
10913        self.port = port if port is not None else 0
10914        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10915        self.port_override = port_override if port_override is not None else 0
10916        self.private_key = private_key if private_key is not None else ''
10917        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10918        '''
10919         ID of the secret store containing credentials for this resource, if any.
10920        '''
10921        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10922        '''
10923         Tags is a map of key, value pairs.
10924        '''
10925        self.username = username if username is not None else ''
10926
10927    def __repr__(self):
10928        return '<sdm.SSHCustomerKey ' + \
10929            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10930            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10931            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10932            'healthy: ' + repr(self.healthy) + ' ' +\
10933            'hostname: ' + repr(self.hostname) + ' ' +\
10934            'id: ' + repr(self.id) + ' ' +\
10935            'name: ' + repr(self.name) + ' ' +\
10936            'port: ' + repr(self.port) + ' ' +\
10937            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10938            'port_override: ' + repr(self.port_override) + ' ' +\
10939            'private_key: ' + repr(self.private_key) + ' ' +\
10940            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10941            'tags: ' + repr(self.tags) + ' ' +\
10942            'username: ' + repr(self.username) + ' ' +\
10943            '>'
10944
10945    def to_dict(self):
10946        return {
10947            'allow_deprecated_key_exchanges':
10948            self.allow_deprecated_key_exchanges,
10949            'bind_interface': self.bind_interface,
10950            'egress_filter': self.egress_filter,
10951            'healthy': self.healthy,
10952            'hostname': self.hostname,
10953            'id': self.id,
10954            'name': self.name,
10955            'port': self.port,
10956            'port_forwarding': self.port_forwarding,
10957            'port_override': self.port_override,
10958            'private_key': self.private_key,
10959            'secret_store_id': self.secret_store_id,
10960            'tags': self.tags,
10961            'username': self.username,
10962        }
10963
10964    @classmethod
10965    def from_dict(cls, d):
10966        return cls(
10967            allow_deprecated_key_exchanges=d.get(
10968                'allow_deprecated_key_exchanges'),
10969            bind_interface=d.get('bind_interface'),
10970            egress_filter=d.get('egress_filter'),
10971            healthy=d.get('healthy'),
10972            hostname=d.get('hostname'),
10973            id=d.get('id'),
10974            name=d.get('name'),
10975            port=d.get('port'),
10976            port_forwarding=d.get('port_forwarding'),
10977            port_override=d.get('port_override'),
10978            private_key=d.get('private_key'),
10979            secret_store_id=d.get('secret_store_id'),
10980            tags=d.get('tags'),
10981            username=d.get('username'),
10982        )
10983
10984
10985class SecretStoreCreateResponse:
10986    '''
10987         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10988    '''
10989    __slots__ = [
10990        'meta',
10991        'rate_limit',
10992        'secret_store',
10993    ]
10994
10995    def __init__(
10996        self,
10997        meta=None,
10998        rate_limit=None,
10999        secret_store=None,
11000    ):
11001        self.meta = meta if meta is not None else None
11002        '''
11003         Reserved for future use.
11004        '''
11005        self.rate_limit = rate_limit if rate_limit is not None else None
11006        '''
11007         Rate limit information.
11008        '''
11009        self.secret_store = secret_store if secret_store is not None else None
11010        '''
11011         The created SecretStore.
11012        '''
11013
11014    def __repr__(self):
11015        return '<sdm.SecretStoreCreateResponse ' + \
11016            'meta: ' + repr(self.meta) + ' ' +\
11017            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11018            'secret_store: ' + repr(self.secret_store) + ' ' +\
11019            '>'
11020
11021    def to_dict(self):
11022        return {
11023            'meta': self.meta,
11024            'rate_limit': self.rate_limit,
11025            'secret_store': self.secret_store,
11026        }
11027
11028    @classmethod
11029    def from_dict(cls, d):
11030        return cls(
11031            meta=d.get('meta'),
11032            rate_limit=d.get('rate_limit'),
11033            secret_store=d.get('secret_store'),
11034        )
11035
11036
11037class SecretStoreDeleteResponse:
11038    '''
11039         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11040    '''
11041    __slots__ = [
11042        'meta',
11043        'rate_limit',
11044    ]
11045
11046    def __init__(
11047        self,
11048        meta=None,
11049        rate_limit=None,
11050    ):
11051        self.meta = meta if meta is not None else None
11052        '''
11053         Reserved for future use.
11054        '''
11055        self.rate_limit = rate_limit if rate_limit is not None else None
11056        '''
11057         Rate limit information.
11058        '''
11059
11060    def __repr__(self):
11061        return '<sdm.SecretStoreDeleteResponse ' + \
11062            'meta: ' + repr(self.meta) + ' ' +\
11063            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11064            '>'
11065
11066    def to_dict(self):
11067        return {
11068            'meta': self.meta,
11069            'rate_limit': self.rate_limit,
11070        }
11071
11072    @classmethod
11073    def from_dict(cls, d):
11074        return cls(
11075            meta=d.get('meta'),
11076            rate_limit=d.get('rate_limit'),
11077        )
11078
11079
11080class SecretStoreGetResponse:
11081    '''
11082         SecretStoreGetResponse returns a requested SecretStore.
11083    '''
11084    __slots__ = [
11085        'meta',
11086        'rate_limit',
11087        'secret_store',
11088    ]
11089
11090    def __init__(
11091        self,
11092        meta=None,
11093        rate_limit=None,
11094        secret_store=None,
11095    ):
11096        self.meta = meta if meta is not None else None
11097        '''
11098         Reserved for future use.
11099        '''
11100        self.rate_limit = rate_limit if rate_limit is not None else None
11101        '''
11102         Rate limit information.
11103        '''
11104        self.secret_store = secret_store if secret_store is not None else None
11105        '''
11106         The requested SecretStore.
11107        '''
11108
11109    def __repr__(self):
11110        return '<sdm.SecretStoreGetResponse ' + \
11111            'meta: ' + repr(self.meta) + ' ' +\
11112            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11113            'secret_store: ' + repr(self.secret_store) + ' ' +\
11114            '>'
11115
11116    def to_dict(self):
11117        return {
11118            'meta': self.meta,
11119            'rate_limit': self.rate_limit,
11120            'secret_store': self.secret_store,
11121        }
11122
11123    @classmethod
11124    def from_dict(cls, d):
11125        return cls(
11126            meta=d.get('meta'),
11127            rate_limit=d.get('rate_limit'),
11128            secret_store=d.get('secret_store'),
11129        )
11130
11131
11132class SecretStoreUpdateResponse:
11133    '''
11134         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11135     a SecretStoreUpdateRequest.
11136    '''
11137    __slots__ = [
11138        'meta',
11139        'rate_limit',
11140        'secret_store',
11141    ]
11142
11143    def __init__(
11144        self,
11145        meta=None,
11146        rate_limit=None,
11147        secret_store=None,
11148    ):
11149        self.meta = meta if meta is not None else None
11150        '''
11151         Reserved for future use.
11152        '''
11153        self.rate_limit = rate_limit if rate_limit is not None else None
11154        '''
11155         Rate limit information.
11156        '''
11157        self.secret_store = secret_store if secret_store is not None else None
11158        '''
11159         The updated SecretStore.
11160        '''
11161
11162    def __repr__(self):
11163        return '<sdm.SecretStoreUpdateResponse ' + \
11164            'meta: ' + repr(self.meta) + ' ' +\
11165            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11166            'secret_store: ' + repr(self.secret_store) + ' ' +\
11167            '>'
11168
11169    def to_dict(self):
11170        return {
11171            'meta': self.meta,
11172            'rate_limit': self.rate_limit,
11173            'secret_store': self.secret_store,
11174        }
11175
11176    @classmethod
11177    def from_dict(cls, d):
11178        return cls(
11179            meta=d.get('meta'),
11180            rate_limit=d.get('rate_limit'),
11181            secret_store=d.get('secret_store'),
11182        )
11183
11184
11185class Service:
11186    '''
11187         A Service is a service account that can connect to resources they are granted
11188     directly, or granted via roles. Services are typically automated jobs.
11189    '''
11190    __slots__ = [
11191        'id',
11192        'name',
11193        'suspended',
11194        'tags',
11195    ]
11196
11197    def __init__(
11198        self,
11199        id=None,
11200        name=None,
11201        suspended=None,
11202        tags=None,
11203    ):
11204        self.id = id if id is not None else ''
11205        '''
11206         Unique identifier of the Service.
11207        '''
11208        self.name = name if name is not None else ''
11209        '''
11210         Unique human-readable name of the Service.
11211        '''
11212        self.suspended = suspended if suspended is not None else False
11213        '''
11214         The Service's suspended state.
11215        '''
11216        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11217        '''
11218         Tags is a map of key, value pairs.
11219        '''
11220
11221    def __repr__(self):
11222        return '<sdm.Service ' + \
11223            'id: ' + repr(self.id) + ' ' +\
11224            'name: ' + repr(self.name) + ' ' +\
11225            'suspended: ' + repr(self.suspended) + ' ' +\
11226            'tags: ' + repr(self.tags) + ' ' +\
11227            '>'
11228
11229    def to_dict(self):
11230        return {
11231            'id': self.id,
11232            'name': self.name,
11233            'suspended': self.suspended,
11234            'tags': self.tags,
11235        }
11236
11237    @classmethod
11238    def from_dict(cls, d):
11239        return cls(
11240            id=d.get('id'),
11241            name=d.get('name'),
11242            suspended=d.get('suspended'),
11243            tags=d.get('tags'),
11244        )
11245
11246
11247class SingleStore:
11248    __slots__ = [
11249        'bind_interface',
11250        'database',
11251        'egress_filter',
11252        'healthy',
11253        'hostname',
11254        'id',
11255        'name',
11256        'password',
11257        'port',
11258        'port_override',
11259        'secret_store_id',
11260        'tags',
11261        'username',
11262    ]
11263
11264    def __init__(
11265        self,
11266        bind_interface=None,
11267        database=None,
11268        egress_filter=None,
11269        healthy=None,
11270        hostname=None,
11271        id=None,
11272        name=None,
11273        password=None,
11274        port=None,
11275        port_override=None,
11276        secret_store_id=None,
11277        tags=None,
11278        username=None,
11279    ):
11280        self.bind_interface = bind_interface if bind_interface is not None else ''
11281        '''
11282         Bind interface
11283        '''
11284        self.database = database if database is not None else ''
11285        self.egress_filter = egress_filter if egress_filter is not None else ''
11286        '''
11287         A filter applied to the routing logic to pin datasource to nodes.
11288        '''
11289        self.healthy = healthy if healthy is not None else False
11290        '''
11291         True if the datasource is reachable and the credentials are valid.
11292        '''
11293        self.hostname = hostname if hostname is not None else ''
11294        self.id = id if id is not None else ''
11295        '''
11296         Unique identifier of the Resource.
11297        '''
11298        self.name = name if name is not None else ''
11299        '''
11300         Unique human-readable name of the Resource.
11301        '''
11302        self.password = password if password is not None else ''
11303        self.port = port if port is not None else 0
11304        self.port_override = port_override if port_override is not None else 0
11305        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11306        '''
11307         ID of the secret store containing credentials for this resource, if any.
11308        '''
11309        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11310        '''
11311         Tags is a map of key, value pairs.
11312        '''
11313        self.username = username if username is not None else ''
11314
11315    def __repr__(self):
11316        return '<sdm.SingleStore ' + \
11317            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11318            'database: ' + repr(self.database) + ' ' +\
11319            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11320            'healthy: ' + repr(self.healthy) + ' ' +\
11321            'hostname: ' + repr(self.hostname) + ' ' +\
11322            'id: ' + repr(self.id) + ' ' +\
11323            'name: ' + repr(self.name) + ' ' +\
11324            'password: ' + repr(self.password) + ' ' +\
11325            'port: ' + repr(self.port) + ' ' +\
11326            'port_override: ' + repr(self.port_override) + ' ' +\
11327            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11328            'tags: ' + repr(self.tags) + ' ' +\
11329            'username: ' + repr(self.username) + ' ' +\
11330            '>'
11331
11332    def to_dict(self):
11333        return {
11334            'bind_interface': self.bind_interface,
11335            'database': self.database,
11336            'egress_filter': self.egress_filter,
11337            'healthy': self.healthy,
11338            'hostname': self.hostname,
11339            'id': self.id,
11340            'name': self.name,
11341            'password': self.password,
11342            'port': self.port,
11343            'port_override': self.port_override,
11344            'secret_store_id': self.secret_store_id,
11345            'tags': self.tags,
11346            'username': self.username,
11347        }
11348
11349    @classmethod
11350    def from_dict(cls, d):
11351        return cls(
11352            bind_interface=d.get('bind_interface'),
11353            database=d.get('database'),
11354            egress_filter=d.get('egress_filter'),
11355            healthy=d.get('healthy'),
11356            hostname=d.get('hostname'),
11357            id=d.get('id'),
11358            name=d.get('name'),
11359            password=d.get('password'),
11360            port=d.get('port'),
11361            port_override=d.get('port_override'),
11362            secret_store_id=d.get('secret_store_id'),
11363            tags=d.get('tags'),
11364            username=d.get('username'),
11365        )
11366
11367
11368class Snowflake:
11369    __slots__ = [
11370        'bind_interface',
11371        'database',
11372        'egress_filter',
11373        'healthy',
11374        'hostname',
11375        'id',
11376        'name',
11377        'password',
11378        'port_override',
11379        'schema',
11380        'secret_store_id',
11381        'tags',
11382        'username',
11383    ]
11384
11385    def __init__(
11386        self,
11387        bind_interface=None,
11388        database=None,
11389        egress_filter=None,
11390        healthy=None,
11391        hostname=None,
11392        id=None,
11393        name=None,
11394        password=None,
11395        port_override=None,
11396        schema=None,
11397        secret_store_id=None,
11398        tags=None,
11399        username=None,
11400    ):
11401        self.bind_interface = bind_interface if bind_interface is not None else ''
11402        '''
11403         Bind interface
11404        '''
11405        self.database = database if database is not None else ''
11406        self.egress_filter = egress_filter if egress_filter is not None else ''
11407        '''
11408         A filter applied to the routing logic to pin datasource to nodes.
11409        '''
11410        self.healthy = healthy if healthy is not None else False
11411        '''
11412         True if the datasource is reachable and the credentials are valid.
11413        '''
11414        self.hostname = hostname if hostname is not None else ''
11415        self.id = id if id is not None else ''
11416        '''
11417         Unique identifier of the Resource.
11418        '''
11419        self.name = name if name is not None else ''
11420        '''
11421         Unique human-readable name of the Resource.
11422        '''
11423        self.password = password if password is not None else ''
11424        self.port_override = port_override if port_override is not None else 0
11425        self.schema = schema if schema is not None else ''
11426        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11427        '''
11428         ID of the secret store containing credentials for this resource, if any.
11429        '''
11430        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11431        '''
11432         Tags is a map of key, value pairs.
11433        '''
11434        self.username = username if username is not None else ''
11435
11436    def __repr__(self):
11437        return '<sdm.Snowflake ' + \
11438            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11439            'database: ' + repr(self.database) + ' ' +\
11440            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11441            'healthy: ' + repr(self.healthy) + ' ' +\
11442            'hostname: ' + repr(self.hostname) + ' ' +\
11443            'id: ' + repr(self.id) + ' ' +\
11444            'name: ' + repr(self.name) + ' ' +\
11445            'password: ' + repr(self.password) + ' ' +\
11446            'port_override: ' + repr(self.port_override) + ' ' +\
11447            'schema: ' + repr(self.schema) + ' ' +\
11448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11449            'tags: ' + repr(self.tags) + ' ' +\
11450            'username: ' + repr(self.username) + ' ' +\
11451            '>'
11452
11453    def to_dict(self):
11454        return {
11455            'bind_interface': self.bind_interface,
11456            'database': self.database,
11457            'egress_filter': self.egress_filter,
11458            'healthy': self.healthy,
11459            'hostname': self.hostname,
11460            'id': self.id,
11461            'name': self.name,
11462            'password': self.password,
11463            'port_override': self.port_override,
11464            'schema': self.schema,
11465            'secret_store_id': self.secret_store_id,
11466            'tags': self.tags,
11467            'username': self.username,
11468        }
11469
11470    @classmethod
11471    def from_dict(cls, d):
11472        return cls(
11473            bind_interface=d.get('bind_interface'),
11474            database=d.get('database'),
11475            egress_filter=d.get('egress_filter'),
11476            healthy=d.get('healthy'),
11477            hostname=d.get('hostname'),
11478            id=d.get('id'),
11479            name=d.get('name'),
11480            password=d.get('password'),
11481            port_override=d.get('port_override'),
11482            schema=d.get('schema'),
11483            secret_store_id=d.get('secret_store_id'),
11484            tags=d.get('tags'),
11485            username=d.get('username'),
11486        )
11487
11488
11489class Snowsight:
11490    '''
11491    Snowsight is currently unstable, and its API may change, or it may be removed,
11492    without a major version bump.
11493    '''
11494    __slots__ = [
11495        'bind_interface',
11496        'egress_filter',
11497        'healthcheck_username',
11498        'healthy',
11499        'id',
11500        'name',
11501        'port_override',
11502        'samlmetadata',
11503        'secret_store_id',
11504        'subdomain',
11505        'tags',
11506    ]
11507
11508    def __init__(
11509        self,
11510        bind_interface=None,
11511        egress_filter=None,
11512        healthcheck_username=None,
11513        healthy=None,
11514        id=None,
11515        name=None,
11516        port_override=None,
11517        samlmetadata=None,
11518        secret_store_id=None,
11519        subdomain=None,
11520        tags=None,
11521    ):
11522        self.bind_interface = bind_interface if bind_interface is not None else ''
11523        '''
11524         Bind interface
11525        '''
11526        self.egress_filter = egress_filter if egress_filter is not None else ''
11527        '''
11528         A filter applied to the routing logic to pin datasource to nodes.
11529        '''
11530        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11531        self.healthy = healthy if healthy is not None else False
11532        '''
11533         True if the datasource is reachable and the credentials are valid.
11534        '''
11535        self.id = id if id is not None else ''
11536        '''
11537         Unique identifier of the Resource.
11538        '''
11539        self.name = name if name is not None else ''
11540        '''
11541         Unique human-readable name of the Resource.
11542        '''
11543        self.port_override = port_override if port_override is not None else 0
11544        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11545        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11546        '''
11547         ID of the secret store containing credentials for this resource, if any.
11548        '''
11549        self.subdomain = subdomain if subdomain is not None else ''
11550        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11551        '''
11552         Tags is a map of key, value pairs.
11553        '''
11554
11555    def __repr__(self):
11556        return '<sdm.Snowsight ' + \
11557            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11558            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11559            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11560            'healthy: ' + repr(self.healthy) + ' ' +\
11561            'id: ' + repr(self.id) + ' ' +\
11562            'name: ' + repr(self.name) + ' ' +\
11563            'port_override: ' + repr(self.port_override) + ' ' +\
11564            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11565            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11566            'subdomain: ' + repr(self.subdomain) + ' ' +\
11567            'tags: ' + repr(self.tags) + ' ' +\
11568            '>'
11569
11570    def to_dict(self):
11571        return {
11572            'bind_interface': self.bind_interface,
11573            'egress_filter': self.egress_filter,
11574            'healthcheck_username': self.healthcheck_username,
11575            'healthy': self.healthy,
11576            'id': self.id,
11577            'name': self.name,
11578            'port_override': self.port_override,
11579            'samlmetadata': self.samlmetadata,
11580            'secret_store_id': self.secret_store_id,
11581            'subdomain': self.subdomain,
11582            'tags': self.tags,
11583        }
11584
11585    @classmethod
11586    def from_dict(cls, d):
11587        return cls(
11588            bind_interface=d.get('bind_interface'),
11589            egress_filter=d.get('egress_filter'),
11590            healthcheck_username=d.get('healthcheck_username'),
11591            healthy=d.get('healthy'),
11592            id=d.get('id'),
11593            name=d.get('name'),
11594            port_override=d.get('port_override'),
11595            samlmetadata=d.get('samlmetadata'),
11596            secret_store_id=d.get('secret_store_id'),
11597            subdomain=d.get('subdomain'),
11598            tags=d.get('tags'),
11599        )
11600
11601
11602class Sybase:
11603    __slots__ = [
11604        'bind_interface',
11605        'egress_filter',
11606        'healthy',
11607        'hostname',
11608        'id',
11609        'name',
11610        'password',
11611        'port',
11612        'port_override',
11613        'secret_store_id',
11614        'tags',
11615        'username',
11616    ]
11617
11618    def __init__(
11619        self,
11620        bind_interface=None,
11621        egress_filter=None,
11622        healthy=None,
11623        hostname=None,
11624        id=None,
11625        name=None,
11626        password=None,
11627        port=None,
11628        port_override=None,
11629        secret_store_id=None,
11630        tags=None,
11631        username=None,
11632    ):
11633        self.bind_interface = bind_interface if bind_interface is not None else ''
11634        '''
11635         Bind interface
11636        '''
11637        self.egress_filter = egress_filter if egress_filter is not None else ''
11638        '''
11639         A filter applied to the routing logic to pin datasource to nodes.
11640        '''
11641        self.healthy = healthy if healthy is not None else False
11642        '''
11643         True if the datasource is reachable and the credentials are valid.
11644        '''
11645        self.hostname = hostname if hostname is not None else ''
11646        self.id = id if id is not None else ''
11647        '''
11648         Unique identifier of the Resource.
11649        '''
11650        self.name = name if name is not None else ''
11651        '''
11652         Unique human-readable name of the Resource.
11653        '''
11654        self.password = password if password is not None else ''
11655        self.port = port if port is not None else 0
11656        self.port_override = port_override if port_override is not None else 0
11657        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11658        '''
11659         ID of the secret store containing credentials for this resource, if any.
11660        '''
11661        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11662        '''
11663         Tags is a map of key, value pairs.
11664        '''
11665        self.username = username if username is not None else ''
11666
11667    def __repr__(self):
11668        return '<sdm.Sybase ' + \
11669            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11670            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11671            'healthy: ' + repr(self.healthy) + ' ' +\
11672            'hostname: ' + repr(self.hostname) + ' ' +\
11673            'id: ' + repr(self.id) + ' ' +\
11674            'name: ' + repr(self.name) + ' ' +\
11675            'password: ' + repr(self.password) + ' ' +\
11676            'port: ' + repr(self.port) + ' ' +\
11677            'port_override: ' + repr(self.port_override) + ' ' +\
11678            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11679            'tags: ' + repr(self.tags) + ' ' +\
11680            'username: ' + repr(self.username) + ' ' +\
11681            '>'
11682
11683    def to_dict(self):
11684        return {
11685            'bind_interface': self.bind_interface,
11686            'egress_filter': self.egress_filter,
11687            'healthy': self.healthy,
11688            'hostname': self.hostname,
11689            'id': self.id,
11690            'name': self.name,
11691            'password': self.password,
11692            'port': self.port,
11693            'port_override': self.port_override,
11694            'secret_store_id': self.secret_store_id,
11695            'tags': self.tags,
11696            'username': self.username,
11697        }
11698
11699    @classmethod
11700    def from_dict(cls, d):
11701        return cls(
11702            bind_interface=d.get('bind_interface'),
11703            egress_filter=d.get('egress_filter'),
11704            healthy=d.get('healthy'),
11705            hostname=d.get('hostname'),
11706            id=d.get('id'),
11707            name=d.get('name'),
11708            password=d.get('password'),
11709            port=d.get('port'),
11710            port_override=d.get('port_override'),
11711            secret_store_id=d.get('secret_store_id'),
11712            tags=d.get('tags'),
11713            username=d.get('username'),
11714        )
11715
11716
11717class SybaseIQ:
11718    __slots__ = [
11719        'bind_interface',
11720        'egress_filter',
11721        'healthy',
11722        'hostname',
11723        'id',
11724        'name',
11725        'password',
11726        'port',
11727        'port_override',
11728        'secret_store_id',
11729        'tags',
11730        'username',
11731    ]
11732
11733    def __init__(
11734        self,
11735        bind_interface=None,
11736        egress_filter=None,
11737        healthy=None,
11738        hostname=None,
11739        id=None,
11740        name=None,
11741        password=None,
11742        port=None,
11743        port_override=None,
11744        secret_store_id=None,
11745        tags=None,
11746        username=None,
11747    ):
11748        self.bind_interface = bind_interface if bind_interface is not None else ''
11749        '''
11750         Bind interface
11751        '''
11752        self.egress_filter = egress_filter if egress_filter is not None else ''
11753        '''
11754         A filter applied to the routing logic to pin datasource to nodes.
11755        '''
11756        self.healthy = healthy if healthy is not None else False
11757        '''
11758         True if the datasource is reachable and the credentials are valid.
11759        '''
11760        self.hostname = hostname if hostname is not None else ''
11761        self.id = id if id is not None else ''
11762        '''
11763         Unique identifier of the Resource.
11764        '''
11765        self.name = name if name is not None else ''
11766        '''
11767         Unique human-readable name of the Resource.
11768        '''
11769        self.password = password if password is not None else ''
11770        self.port = port if port is not None else 0
11771        self.port_override = port_override if port_override is not None else 0
11772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11773        '''
11774         ID of the secret store containing credentials for this resource, if any.
11775        '''
11776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11777        '''
11778         Tags is a map of key, value pairs.
11779        '''
11780        self.username = username if username is not None else ''
11781
11782    def __repr__(self):
11783        return '<sdm.SybaseIQ ' + \
11784            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11785            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11786            'healthy: ' + repr(self.healthy) + ' ' +\
11787            'hostname: ' + repr(self.hostname) + ' ' +\
11788            'id: ' + repr(self.id) + ' ' +\
11789            'name: ' + repr(self.name) + ' ' +\
11790            'password: ' + repr(self.password) + ' ' +\
11791            'port: ' + repr(self.port) + ' ' +\
11792            'port_override: ' + repr(self.port_override) + ' ' +\
11793            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11794            'tags: ' + repr(self.tags) + ' ' +\
11795            'username: ' + repr(self.username) + ' ' +\
11796            '>'
11797
11798    def to_dict(self):
11799        return {
11800            'bind_interface': self.bind_interface,
11801            'egress_filter': self.egress_filter,
11802            'healthy': self.healthy,
11803            'hostname': self.hostname,
11804            'id': self.id,
11805            'name': self.name,
11806            'password': self.password,
11807            'port': self.port,
11808            'port_override': self.port_override,
11809            'secret_store_id': self.secret_store_id,
11810            'tags': self.tags,
11811            'username': self.username,
11812        }
11813
11814    @classmethod
11815    def from_dict(cls, d):
11816        return cls(
11817            bind_interface=d.get('bind_interface'),
11818            egress_filter=d.get('egress_filter'),
11819            healthy=d.get('healthy'),
11820            hostname=d.get('hostname'),
11821            id=d.get('id'),
11822            name=d.get('name'),
11823            password=d.get('password'),
11824            port=d.get('port'),
11825            port_override=d.get('port_override'),
11826            secret_store_id=d.get('secret_store_id'),
11827            tags=d.get('tags'),
11828            username=d.get('username'),
11829        )
11830
11831
11832class Tag:
11833    __slots__ = [
11834        'name',
11835        'value',
11836    ]
11837
11838    def __init__(
11839        self,
11840        name=None,
11841        value=None,
11842    ):
11843        self.name = name if name is not None else ''
11844        self.value = value if value is not None else ''
11845
11846    def __repr__(self):
11847        return '<sdm.Tag ' + \
11848            'name: ' + repr(self.name) + ' ' +\
11849            'value: ' + repr(self.value) + ' ' +\
11850            '>'
11851
11852    def to_dict(self):
11853        return {
11854            'name': self.name,
11855            'value': self.value,
11856        }
11857
11858    @classmethod
11859    def from_dict(cls, d):
11860        return cls(
11861            name=d.get('name'),
11862            value=d.get('value'),
11863        )
11864
11865
11866class Teradata:
11867    __slots__ = [
11868        'bind_interface',
11869        'egress_filter',
11870        'healthy',
11871        'hostname',
11872        'id',
11873        'name',
11874        'password',
11875        'port',
11876        'port_override',
11877        'secret_store_id',
11878        'tags',
11879        'username',
11880    ]
11881
11882    def __init__(
11883        self,
11884        bind_interface=None,
11885        egress_filter=None,
11886        healthy=None,
11887        hostname=None,
11888        id=None,
11889        name=None,
11890        password=None,
11891        port=None,
11892        port_override=None,
11893        secret_store_id=None,
11894        tags=None,
11895        username=None,
11896    ):
11897        self.bind_interface = bind_interface if bind_interface is not None else ''
11898        '''
11899         Bind interface
11900        '''
11901        self.egress_filter = egress_filter if egress_filter is not None else ''
11902        '''
11903         A filter applied to the routing logic to pin datasource to nodes.
11904        '''
11905        self.healthy = healthy if healthy is not None else False
11906        '''
11907         True if the datasource is reachable and the credentials are valid.
11908        '''
11909        self.hostname = hostname if hostname is not None else ''
11910        self.id = id if id is not None else ''
11911        '''
11912         Unique identifier of the Resource.
11913        '''
11914        self.name = name if name is not None else ''
11915        '''
11916         Unique human-readable name of the Resource.
11917        '''
11918        self.password = password if password is not None else ''
11919        self.port = port if port is not None else 0
11920        self.port_override = port_override if port_override is not None else 0
11921        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11922        '''
11923         ID of the secret store containing credentials for this resource, if any.
11924        '''
11925        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11926        '''
11927         Tags is a map of key, value pairs.
11928        '''
11929        self.username = username if username is not None else ''
11930
11931    def __repr__(self):
11932        return '<sdm.Teradata ' + \
11933            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11934            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11935            'healthy: ' + repr(self.healthy) + ' ' +\
11936            'hostname: ' + repr(self.hostname) + ' ' +\
11937            'id: ' + repr(self.id) + ' ' +\
11938            'name: ' + repr(self.name) + ' ' +\
11939            'password: ' + repr(self.password) + ' ' +\
11940            'port: ' + repr(self.port) + ' ' +\
11941            'port_override: ' + repr(self.port_override) + ' ' +\
11942            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11943            'tags: ' + repr(self.tags) + ' ' +\
11944            'username: ' + repr(self.username) + ' ' +\
11945            '>'
11946
11947    def to_dict(self):
11948        return {
11949            'bind_interface': self.bind_interface,
11950            'egress_filter': self.egress_filter,
11951            'healthy': self.healthy,
11952            'hostname': self.hostname,
11953            'id': self.id,
11954            'name': self.name,
11955            'password': self.password,
11956            'port': self.port,
11957            'port_override': self.port_override,
11958            'secret_store_id': self.secret_store_id,
11959            'tags': self.tags,
11960            'username': self.username,
11961        }
11962
11963    @classmethod
11964    def from_dict(cls, d):
11965        return cls(
11966            bind_interface=d.get('bind_interface'),
11967            egress_filter=d.get('egress_filter'),
11968            healthy=d.get('healthy'),
11969            hostname=d.get('hostname'),
11970            id=d.get('id'),
11971            name=d.get('name'),
11972            password=d.get('password'),
11973            port=d.get('port'),
11974            port_override=d.get('port_override'),
11975            secret_store_id=d.get('secret_store_id'),
11976            tags=d.get('tags'),
11977            username=d.get('username'),
11978        )
11979
11980
11981class UpdateResponseMetadata:
11982    '''
11983         UpdateResponseMetadata is reserved for future use.
11984    '''
11985    __slots__ = []
11986
11987    def __init__(self, ):
11988        pass
11989
11990    def __repr__(self):
11991        return '<sdm.UpdateResponseMetadata ' + \
11992            '>'
11993
11994    def to_dict(self):
11995        return {}
11996
11997    @classmethod
11998    def from_dict(cls, d):
11999        return cls()
12000
12001
12002class User:
12003    '''
12004         A User can connect to resources they are granted directly, or granted
12005     via roles.
12006    '''
12007    __slots__ = [
12008        'email',
12009        'first_name',
12010        'id',
12011        'last_name',
12012        'suspended',
12013        'tags',
12014    ]
12015
12016    def __init__(
12017        self,
12018        email=None,
12019        first_name=None,
12020        id=None,
12021        last_name=None,
12022        suspended=None,
12023        tags=None,
12024    ):
12025        self.email = email if email is not None else ''
12026        '''
12027         The User's email address. Must be unique.
12028        '''
12029        self.first_name = first_name if first_name is not None else ''
12030        '''
12031         The User's first name.
12032        '''
12033        self.id = id if id is not None else ''
12034        '''
12035         Unique identifier of the User.
12036        '''
12037        self.last_name = last_name if last_name is not None else ''
12038        '''
12039         The User's last name.
12040        '''
12041        self.suspended = suspended if suspended is not None else False
12042        '''
12043         The User's suspended state.
12044        '''
12045        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12046        '''
12047         Tags is a map of key, value pairs.
12048        '''
12049
12050    def __repr__(self):
12051        return '<sdm.User ' + \
12052            'email: ' + repr(self.email) + ' ' +\
12053            'first_name: ' + repr(self.first_name) + ' ' +\
12054            'id: ' + repr(self.id) + ' ' +\
12055            'last_name: ' + repr(self.last_name) + ' ' +\
12056            'suspended: ' + repr(self.suspended) + ' ' +\
12057            'tags: ' + repr(self.tags) + ' ' +\
12058            '>'
12059
12060    def to_dict(self):
12061        return {
12062            'email': self.email,
12063            'first_name': self.first_name,
12064            'id': self.id,
12065            'last_name': self.last_name,
12066            'suspended': self.suspended,
12067            'tags': self.tags,
12068        }
12069
12070    @classmethod
12071    def from_dict(cls, d):
12072        return cls(
12073            email=d.get('email'),
12074            first_name=d.get('first_name'),
12075            id=d.get('id'),
12076            last_name=d.get('last_name'),
12077            suspended=d.get('suspended'),
12078            tags=d.get('tags'),
12079        )
12080
12081
12082class VaultAppRoleStore:
12083    __slots__ = [
12084        'id',
12085        'name',
12086        'namespace',
12087        'server_address',
12088        'tags',
12089    ]
12090
12091    def __init__(
12092        self,
12093        id=None,
12094        name=None,
12095        namespace=None,
12096        server_address=None,
12097        tags=None,
12098    ):
12099        self.id = id if id is not None else ''
12100        '''
12101         Unique identifier of the SecretStore.
12102        '''
12103        self.name = name if name is not None else ''
12104        '''
12105         Unique human-readable name of the SecretStore.
12106        '''
12107        self.namespace = namespace if namespace is not None else ''
12108        self.server_address = server_address if server_address is not None else ''
12109        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12110        '''
12111         Tags is a map of key, value pairs.
12112        '''
12113
12114    def __repr__(self):
12115        return '<sdm.VaultAppRoleStore ' + \
12116            'id: ' + repr(self.id) + ' ' +\
12117            'name: ' + repr(self.name) + ' ' +\
12118            'namespace: ' + repr(self.namespace) + ' ' +\
12119            'server_address: ' + repr(self.server_address) + ' ' +\
12120            'tags: ' + repr(self.tags) + ' ' +\
12121            '>'
12122
12123    def to_dict(self):
12124        return {
12125            'id': self.id,
12126            'name': self.name,
12127            'namespace': self.namespace,
12128            'server_address': self.server_address,
12129            'tags': self.tags,
12130        }
12131
12132    @classmethod
12133    def from_dict(cls, d):
12134        return cls(
12135            id=d.get('id'),
12136            name=d.get('name'),
12137            namespace=d.get('namespace'),
12138            server_address=d.get('server_address'),
12139            tags=d.get('tags'),
12140        )
12141
12142
12143class VaultTLSStore:
12144    __slots__ = [
12145        'ca_cert_path',
12146        'client_cert_path',
12147        'client_key_path',
12148        'id',
12149        'name',
12150        'namespace',
12151        'server_address',
12152        'tags',
12153    ]
12154
12155    def __init__(
12156        self,
12157        ca_cert_path=None,
12158        client_cert_path=None,
12159        client_key_path=None,
12160        id=None,
12161        name=None,
12162        namespace=None,
12163        server_address=None,
12164        tags=None,
12165    ):
12166        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12167        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12168        self.client_key_path = client_key_path if client_key_path is not None else ''
12169        self.id = id if id is not None else ''
12170        '''
12171         Unique identifier of the SecretStore.
12172        '''
12173        self.name = name if name is not None else ''
12174        '''
12175         Unique human-readable name of the SecretStore.
12176        '''
12177        self.namespace = namespace if namespace is not None else ''
12178        self.server_address = server_address if server_address is not None else ''
12179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12180        '''
12181         Tags is a map of key, value pairs.
12182        '''
12183
12184    def __repr__(self):
12185        return '<sdm.VaultTLSStore ' + \
12186            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12187            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12188            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12189            'id: ' + repr(self.id) + ' ' +\
12190            'name: ' + repr(self.name) + ' ' +\
12191            'namespace: ' + repr(self.namespace) + ' ' +\
12192            'server_address: ' + repr(self.server_address) + ' ' +\
12193            'tags: ' + repr(self.tags) + ' ' +\
12194            '>'
12195
12196    def to_dict(self):
12197        return {
12198            'ca_cert_path': self.ca_cert_path,
12199            'client_cert_path': self.client_cert_path,
12200            'client_key_path': self.client_key_path,
12201            'id': self.id,
12202            'name': self.name,
12203            'namespace': self.namespace,
12204            'server_address': self.server_address,
12205            'tags': self.tags,
12206        }
12207
12208    @classmethod
12209    def from_dict(cls, d):
12210        return cls(
12211            ca_cert_path=d.get('ca_cert_path'),
12212            client_cert_path=d.get('client_cert_path'),
12213            client_key_path=d.get('client_key_path'),
12214            id=d.get('id'),
12215            name=d.get('name'),
12216            namespace=d.get('namespace'),
12217            server_address=d.get('server_address'),
12218            tags=d.get('tags'),
12219        )
12220
12221
12222class VaultTokenStore:
12223    __slots__ = [
12224        'id',
12225        'name',
12226        'namespace',
12227        'server_address',
12228        'tags',
12229    ]
12230
12231    def __init__(
12232        self,
12233        id=None,
12234        name=None,
12235        namespace=None,
12236        server_address=None,
12237        tags=None,
12238    ):
12239        self.id = id if id is not None else ''
12240        '''
12241         Unique identifier of the SecretStore.
12242        '''
12243        self.name = name if name is not None else ''
12244        '''
12245         Unique human-readable name of the SecretStore.
12246        '''
12247        self.namespace = namespace if namespace is not None else ''
12248        self.server_address = server_address if server_address is not None else ''
12249        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12250        '''
12251         Tags is a map of key, value pairs.
12252        '''
12253
12254    def __repr__(self):
12255        return '<sdm.VaultTokenStore ' + \
12256            'id: ' + repr(self.id) + ' ' +\
12257            'name: ' + repr(self.name) + ' ' +\
12258            'namespace: ' + repr(self.namespace) + ' ' +\
12259            'server_address: ' + repr(self.server_address) + ' ' +\
12260            'tags: ' + repr(self.tags) + ' ' +\
12261            '>'
12262
12263    def to_dict(self):
12264        return {
12265            'id': self.id,
12266            'name': self.name,
12267            'namespace': self.namespace,
12268            'server_address': self.server_address,
12269            'tags': self.tags,
12270        }
12271
12272    @classmethod
12273    def from_dict(cls, d):
12274        return cls(
12275            id=d.get('id'),
12276            name=d.get('name'),
12277            namespace=d.get('namespace'),
12278            server_address=d.get('server_address'),
12279            tags=d.get('tags'),
12280        )
12281
12282
12283def _porcelain_zero_value_tags():
12284    return {}
12285
12286
12287def _porcelain_zero_value_access_rules():
12288    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSConsole:
785class AWSConsole:
786    '''
787    AWSConsole is currently unstable, and its API may change, or it may be removed,
788    without a major version bump.
789    '''
790    __slots__ = [
791        'bind_interface',
792        'egress_filter',
793        'enable_env_variables',
794        'healthy',
795        'id',
796        'name',
797        'port_override',
798        'region',
799        'remote_identity_group_id',
800        'remote_identity_healthcheck_username',
801        'role_arn',
802        'role_external_id',
803        'secret_store_id',
804        'session_expiry',
805        'subdomain',
806        'tags',
807    ]
808
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
865
866    def __repr__(self):
867        return '<sdm.AWSConsole ' + \
868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
870            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
871            'healthy: ' + repr(self.healthy) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'name: ' + repr(self.name) + ' ' +\
874            'port_override: ' + repr(self.port_override) + ' ' +\
875            'region: ' + repr(self.region) + ' ' +\
876            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
877            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
878            'role_arn: ' + repr(self.role_arn) + ' ' +\
879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
881            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
882            'subdomain: ' + repr(self.subdomain) + ' ' +\
883            'tags: ' + repr(self.tags) + ' ' +\
884            '>'
885
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
906
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )

AWSConsole is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsole( bind_interface=None, egress_filter=None, enable_env_variables=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

enable_env_variables
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
@classmethod
def from_dict(cls, d)
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )
class AWSConsoleStaticKeyPair:
 930class AWSConsoleStaticKeyPair:
 931    '''
 932    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
 933    without a major version bump.
 934    '''
 935    __slots__ = [
 936        'access_key',
 937        'bind_interface',
 938        'egress_filter',
 939        'healthy',
 940        'id',
 941        'name',
 942        'port_override',
 943        'region',
 944        'remote_identity_group_id',
 945        'remote_identity_healthcheck_username',
 946        'role_arn',
 947        'role_external_id',
 948        'secret_access_key',
 949        'secret_store_id',
 950        'session_expiry',
 951        'subdomain',
 952        'tags',
 953    ]
 954
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
1013
1014    def __repr__(self):
1015        return '<sdm.AWSConsoleStaticKeyPair ' + \
1016            'access_key: ' + repr(self.access_key) + ' ' +\
1017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1019            'healthy: ' + repr(self.healthy) + ' ' +\
1020            'id: ' + repr(self.id) + ' ' +\
1021            'name: ' + repr(self.name) + ' ' +\
1022            'port_override: ' + repr(self.port_override) + ' ' +\
1023            'region: ' + repr(self.region) + ' ' +\
1024            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1025            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1026            'role_arn: ' + repr(self.role_arn) + ' ' +\
1027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1030            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
1031            'subdomain: ' + repr(self.subdomain) + ' ' +\
1032            'tags: ' + repr(self.tags) + ' ' +\
1033            '>'
1034
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
1056
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )

AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsoleStaticKeyPair( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
@classmethod
def from_dict(cls, d)
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )
class AWSStore:
1081class AWSStore:
1082    __slots__ = [
1083        'id',
1084        'name',
1085        'region',
1086        'tags',
1087    ]
1088
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AWSStore ' + \
1112            'id: ' + repr(self.id) + ' ' +\
1113            'name: ' + repr(self.name) + ' ' +\
1114            'region: ' + repr(self.region) + ' ' +\
1115            'tags: ' + repr(self.tags) + ' ' +\
1116            '>'
1117
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
1125
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
AWSStore(id=None, name=None, region=None, tags=None)
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
@classmethod
def from_dict(cls, d)
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
class AccountAttachment:
1136class AccountAttachment:
1137    '''
1138         AccountAttachments assign an account to a role.
1139    '''
1140    __slots__ = [
1141        'account_id',
1142        'id',
1143        'role_id',
1144    ]
1145
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
1164
1165    def __repr__(self):
1166        return '<sdm.AccountAttachment ' + \
1167            'account_id: ' + repr(self.account_id) + ' ' +\
1168            'id: ' + repr(self.id) + ' ' +\
1169            'role_id: ' + repr(self.role_id) + ' ' +\
1170            '>'
1171
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
1178
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
@classmethod
def from_dict(cls, d)
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )
class AccountAttachmentCreateResponse:
1188class AccountAttachmentCreateResponse:
1189    '''
1190         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1191    '''
1192    __slots__ = [
1193        'account_attachment',
1194        'meta',
1195        'rate_limit',
1196    ]
1197
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
1216
1217    def __repr__(self):
1218        return '<sdm.AccountAttachmentCreateResponse ' + \
1219            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1220            'meta: ' + repr(self.meta) + ' ' +\
1221            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1222            '>'
1223
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
1230
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
@classmethod
def from_dict(cls, d)
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )
class AccountAttachmentDeleteResponse:
1240class AccountAttachmentDeleteResponse:
1241    '''
1242         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1243    '''
1244    __slots__ = [
1245        'meta',
1246        'rate_limit',
1247    ]
1248
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
1262
1263    def __repr__(self):
1264        return '<sdm.AccountAttachmentDeleteResponse ' + \
1265            'meta: ' + repr(self.meta) + ' ' +\
1266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1267            '>'
1268
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
1274
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
@classmethod
def from_dict(cls, d)
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )
class AccountAttachmentGetResponse:
1283class AccountAttachmentGetResponse:
1284    '''
1285         AccountAttachmentGetResponse returns a requested AccountAttachment.
1286    '''
1287    __slots__ = [
1288        'account_attachment',
1289        'meta',
1290        'rate_limit',
1291    ]
1292
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
1311
1312    def __repr__(self):
1313        return '<sdm.AccountAttachmentGetResponse ' + \
1314            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1315            'meta: ' + repr(self.meta) + ' ' +\
1316            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1317            '>'
1318
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
1325
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
@classmethod
def from_dict(cls, d)
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )
class AccountCreateResponse:
1335class AccountCreateResponse:
1336    '''
1337         AccountCreateResponse reports how the Accounts were created in the system.
1338    '''
1339    __slots__ = [
1340        'account',
1341        'meta',
1342        'rate_limit',
1343        'token',
1344    ]
1345
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
1370
1371    def __repr__(self):
1372        return '<sdm.AccountCreateResponse ' + \
1373            'account: ' + repr(self.account) + ' ' +\
1374            'meta: ' + repr(self.meta) + ' ' +\
1375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1376            'token: ' + repr(self.token) + ' ' +\
1377            '>'
1378
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
1386
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
@classmethod
def from_dict(cls, d)
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )
class AccountDeleteResponse:
1397class AccountDeleteResponse:
1398    '''
1399         AccountDeleteResponse returns information about a Account that was deleted.
1400    '''
1401    __slots__ = [
1402        'meta',
1403        'rate_limit',
1404    ]
1405
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
1419
1420    def __repr__(self):
1421        return '<sdm.AccountDeleteResponse ' + \
1422            'meta: ' + repr(self.meta) + ' ' +\
1423            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1424            '>'
1425
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
1431
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
@classmethod
def from_dict(cls, d)
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )
class AccountGetResponse:
1440class AccountGetResponse:
1441    '''
1442         AccountGetResponse returns a requested Account.
1443    '''
1444    __slots__ = [
1445        'account',
1446        'meta',
1447        'rate_limit',
1448    ]
1449
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGetResponse ' + \
1471            'account: ' + repr(self.account) + ' ' +\
1472            'meta: ' + repr(self.meta) + ' ' +\
1473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1474            '>'
1475
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
1482
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
@classmethod
def from_dict(cls, d)
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )
class AccountGrant:
1492class AccountGrant:
1493    '''
1494         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1495    '''
1496    __slots__ = [
1497        'account_id',
1498        'id',
1499        'resource_id',
1500        'start_from',
1501        'valid_until',
1502    ]
1503
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
1532
1533    def __repr__(self):
1534        return '<sdm.AccountGrant ' + \
1535            'account_id: ' + repr(self.account_id) + ' ' +\
1536            'id: ' + repr(self.id) + ' ' +\
1537            'resource_id: ' + repr(self.resource_id) + ' ' +\
1538            'start_from: ' + repr(self.start_from) + ' ' +\
1539            'valid_until: ' + repr(self.valid_until) + ' ' +\
1540            '>'
1541
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
1550
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
@classmethod
def from_dict(cls, d)
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )
class AccountGrantCreateResponse:
1562class AccountGrantCreateResponse:
1563    '''
1564         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1565    '''
1566    __slots__ = [
1567        'account_grant',
1568        'meta',
1569        'rate_limit',
1570    ]
1571
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
1590
1591    def __repr__(self):
1592        return '<sdm.AccountGrantCreateResponse ' + \
1593            'account_grant: ' + repr(self.account_grant) + ' ' +\
1594            'meta: ' + repr(self.meta) + ' ' +\
1595            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1596            '>'
1597
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
1604
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
@classmethod
def from_dict(cls, d)
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )
class AccountGrantDeleteResponse:
1614class AccountGrantDeleteResponse:
1615    '''
1616         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1617    '''
1618    __slots__ = [
1619        'meta',
1620        'rate_limit',
1621    ]
1622
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
1636
1637    def __repr__(self):
1638        return '<sdm.AccountGrantDeleteResponse ' + \
1639            'meta: ' + repr(self.meta) + ' ' +\
1640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1641            '>'
1642
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
1648
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
@classmethod
def from_dict(cls, d)
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )
class AccountGrantGetResponse:
1657class AccountGrantGetResponse:
1658    '''
1659         AccountGrantGetResponse returns a requested AccountGrant.
1660    '''
1661    __slots__ = [
1662        'account_grant',
1663        'meta',
1664        'rate_limit',
1665    ]
1666
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
1685
1686    def __repr__(self):
1687        return '<sdm.AccountGrantGetResponse ' + \
1688            'account_grant: ' + repr(self.account_grant) + ' ' +\
1689            'meta: ' + repr(self.meta) + ' ' +\
1690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1691            '>'
1692
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
1699
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
@classmethod
def from_dict(cls, d)
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )
class AccountUpdateResponse:
1709class AccountUpdateResponse:
1710    '''
1711         AccountUpdateResponse returns the fields of a Account after it has been updated by
1712     a AccountUpdateRequest.
1713    '''
1714    __slots__ = [
1715        'account',
1716        'meta',
1717        'rate_limit',
1718    ]
1719
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
1738
1739    def __repr__(self):
1740        return '<sdm.AccountUpdateResponse ' + \
1741            'account: ' + repr(self.account) + ' ' +\
1742            'meta: ' + repr(self.meta) + ' ' +\
1743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1744            '>'
1745
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
@classmethod
def from_dict(cls, d)
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )
class AmazonEKS:
1762class AmazonEKS:
1763    __slots__ = [
1764        'access_key',
1765        'bind_interface',
1766        'certificate_authority',
1767        'cluster_name',
1768        'egress_filter',
1769        'endpoint',
1770        'healthcheck_namespace',
1771        'healthy',
1772        'id',
1773        'name',
1774        'region',
1775        'remote_identity_group_id',
1776        'remote_identity_healthcheck_username',
1777        'role_arn',
1778        'role_external_id',
1779        'secret_access_key',
1780        'secret_store_id',
1781        'tags',
1782    ]
1783
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
1847
1848    def __repr__(self):
1849        return '<sdm.AmazonEKS ' + \
1850            'access_key: ' + repr(self.access_key) + ' ' +\
1851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1852            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1853            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1855            'endpoint: ' + repr(self.endpoint) + ' ' +\
1856            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1857            'healthy: ' + repr(self.healthy) + ' ' +\
1858            'id: ' + repr(self.id) + ' ' +\
1859            'name: ' + repr(self.name) + ' ' +\
1860            'region: ' + repr(self.region) + ' ' +\
1861            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1862            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1863            'role_arn: ' + repr(self.role_arn) + ' ' +\
1864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1867            'tags: ' + repr(self.tags) + ' ' +\
1868            '>'
1869
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
1892
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
@classmethod
def from_dict(cls, d)
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
class AmazonEKSUserImpersonation:
1918class AmazonEKSUserImpersonation:
1919    __slots__ = [
1920        'access_key',
1921        'bind_interface',
1922        'certificate_authority',
1923        'cluster_name',
1924        'egress_filter',
1925        'endpoint',
1926        'healthcheck_namespace',
1927        'healthy',
1928        'id',
1929        'name',
1930        'region',
1931        'role_arn',
1932        'role_external_id',
1933        'secret_access_key',
1934        'secret_store_id',
1935        'tags',
1936    ]
1937
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
1997
1998    def __repr__(self):
1999        return '<sdm.AmazonEKSUserImpersonation ' + \
2000            'access_key: ' + repr(self.access_key) + ' ' +\
2001            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2002            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2003            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2005            'endpoint: ' + repr(self.endpoint) + ' ' +\
2006            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2007            'healthy: ' + repr(self.healthy) + ' ' +\
2008            'id: ' + repr(self.id) + ' ' +\
2009            'name: ' + repr(self.name) + ' ' +\
2010            'region: ' + repr(self.region) + ' ' +\
2011            'role_arn: ' + repr(self.role_arn) + ' ' +\
2012            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2013            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2014            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2015            'tags: ' + repr(self.tags) + ' ' +\
2016            '>'
2017
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
2037
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
@classmethod
def from_dict(cls, d)
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
class AmazonES:
2060class AmazonES:
2061    __slots__ = [
2062        'access_key',
2063        'bind_interface',
2064        'egress_filter',
2065        'endpoint',
2066        'healthy',
2067        'id',
2068        'name',
2069        'port_override',
2070        'region',
2071        'role_arn',
2072        'role_external_id',
2073        'secret_access_key',
2074        'secret_store_id',
2075        'tags',
2076    ]
2077
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
2130
2131    def __repr__(self):
2132        return '<sdm.AmazonES ' + \
2133            'access_key: ' + repr(self.access_key) + ' ' +\
2134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2136            'endpoint: ' + repr(self.endpoint) + ' ' +\
2137            'healthy: ' + repr(self.healthy) + ' ' +\
2138            'id: ' + repr(self.id) + ' ' +\
2139            'name: ' + repr(self.name) + ' ' +\
2140            'port_override: ' + repr(self.port_override) + ' ' +\
2141            'region: ' + repr(self.region) + ' ' +\
2142            'role_arn: ' + repr(self.role_arn) + ' ' +\
2143            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2144            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2146            'tags: ' + repr(self.tags) + ' ' +\
2147            '>'
2148
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
2166
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
@classmethod
def from_dict(cls, d)
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
class AmazonMQAMQP091:
2187class AmazonMQAMQP091:
2188    __slots__ = [
2189        'bind_interface',
2190        'egress_filter',
2191        'healthy',
2192        'hostname',
2193        'id',
2194        'name',
2195        'password',
2196        'port',
2197        'port_override',
2198        'secret_store_id',
2199        'tags',
2200        'tls_required',
2201        'username',
2202    ]
2203
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
2254
2255    def __repr__(self):
2256        return '<sdm.AmazonMQAMQP091 ' + \
2257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2258            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2259            'healthy: ' + repr(self.healthy) + ' ' +\
2260            'hostname: ' + repr(self.hostname) + ' ' +\
2261            'id: ' + repr(self.id) + ' ' +\
2262            'name: ' + repr(self.name) + ' ' +\
2263            'password: ' + repr(self.password) + ' ' +\
2264            'port: ' + repr(self.port) + ' ' +\
2265            'port_override: ' + repr(self.port_override) + ' ' +\
2266            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2267            'tags: ' + repr(self.tags) + ' ' +\
2268            'tls_required: ' + repr(self.tls_required) + ' ' +\
2269            'username: ' + repr(self.username) + ' ' +\
2270            '>'
2271
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
2288
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
@classmethod
def from_dict(cls, d)
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
class Athena:
2308class Athena:
2309    __slots__ = [
2310        'access_key',
2311        'bind_interface',
2312        'egress_filter',
2313        'healthy',
2314        'id',
2315        'name',
2316        'output',
2317        'port_override',
2318        'region',
2319        'role_arn',
2320        'role_external_id',
2321        'secret_access_key',
2322        'secret_store_id',
2323        'tags',
2324    ]
2325
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
2378
2379    def __repr__(self):
2380        return '<sdm.Athena ' + \
2381            'access_key: ' + repr(self.access_key) + ' ' +\
2382            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2384            'healthy: ' + repr(self.healthy) + ' ' +\
2385            'id: ' + repr(self.id) + ' ' +\
2386            'name: ' + repr(self.name) + ' ' +\
2387            'output: ' + repr(self.output) + ' ' +\
2388            'port_override: ' + repr(self.port_override) + ' ' +\
2389            'region: ' + repr(self.region) + ' ' +\
2390            'role_arn: ' + repr(self.role_arn) + ' ' +\
2391            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2392            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2393            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2394            'tags: ' + repr(self.tags) + ' ' +\
2395            '>'
2396
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
2414
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
@classmethod
def from_dict(cls, d)
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
class AuroraMysql:
2435class AuroraMysql:
2436    __slots__ = [
2437        'bind_interface',
2438        'database',
2439        'egress_filter',
2440        'healthy',
2441        'hostname',
2442        'id',
2443        'name',
2444        'password',
2445        'port',
2446        'port_override',
2447        'secret_store_id',
2448        'tags',
2449        'username',
2450    ]
2451
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
2502
2503    def __repr__(self):
2504        return '<sdm.AuroraMysql ' + \
2505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2506            'database: ' + repr(self.database) + ' ' +\
2507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2508            'healthy: ' + repr(self.healthy) + ' ' +\
2509            'hostname: ' + repr(self.hostname) + ' ' +\
2510            'id: ' + repr(self.id) + ' ' +\
2511            'name: ' + repr(self.name) + ' ' +\
2512            'password: ' + repr(self.password) + ' ' +\
2513            'port: ' + repr(self.port) + ' ' +\
2514            'port_override: ' + repr(self.port_override) + ' ' +\
2515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2516            'tags: ' + repr(self.tags) + ' ' +\
2517            'username: ' + repr(self.username) + ' ' +\
2518            '>'
2519
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
2536
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
@classmethod
def from_dict(cls, d)
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
class AuroraPostgres:
2556class AuroraPostgres:
2557    __slots__ = [
2558        'bind_interface',
2559        'database',
2560        'egress_filter',
2561        'healthy',
2562        'hostname',
2563        'id',
2564        'name',
2565        'override_database',
2566        'password',
2567        'port',
2568        'port_override',
2569        'secret_store_id',
2570        'tags',
2571        'username',
2572    ]
2573
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
2626
2627    def __repr__(self):
2628        return '<sdm.AuroraPostgres ' + \
2629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2630            'database: ' + repr(self.database) + ' ' +\
2631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2632            'healthy: ' + repr(self.healthy) + ' ' +\
2633            'hostname: ' + repr(self.hostname) + ' ' +\
2634            'id: ' + repr(self.id) + ' ' +\
2635            'name: ' + repr(self.name) + ' ' +\
2636            'override_database: ' + repr(self.override_database) + ' ' +\
2637            'password: ' + repr(self.password) + ' ' +\
2638            'port: ' + repr(self.port) + ' ' +\
2639            'port_override: ' + repr(self.port_override) + ' ' +\
2640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2641            'tags: ' + repr(self.tags) + ' ' +\
2642            'username: ' + repr(self.username) + ' ' +\
2643            '>'
2644
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
2662
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
@classmethod
def from_dict(cls, d)
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
class Azure:
2683class Azure:
2684    __slots__ = [
2685        'app_id',
2686        'bind_interface',
2687        'egress_filter',
2688        'healthy',
2689        'id',
2690        'name',
2691        'password',
2692        'secret_store_id',
2693        'tags',
2694        'tenant_id',
2695    ]
2696
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
2741
2742    def __repr__(self):
2743        return '<sdm.Azure ' + \
2744            'app_id: ' + repr(self.app_id) + ' ' +\
2745            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2747            'healthy: ' + repr(self.healthy) + ' ' +\
2748            'id: ' + repr(self.id) + ' ' +\
2749            'name: ' + repr(self.name) + ' ' +\
2750            'password: ' + repr(self.password) + ' ' +\
2751            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2752            'tags: ' + repr(self.tags) + ' ' +\
2753            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2754            '>'
2755
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
2769
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
@classmethod
def from_dict(cls, d)
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
class AzureCertificate:
2786class AzureCertificate:
2787    __slots__ = [
2788        'app_id',
2789        'bind_interface',
2790        'client_certificate',
2791        'egress_filter',
2792        'healthy',
2793        'id',
2794        'name',
2795        'secret_store_id',
2796        'tags',
2797        'tenant_id',
2798    ]
2799
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
2844
2845    def __repr__(self):
2846        return '<sdm.AzureCertificate ' + \
2847            'app_id: ' + repr(self.app_id) + ' ' +\
2848            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2849            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2851            'healthy: ' + repr(self.healthy) + ' ' +\
2852            'id: ' + repr(self.id) + ' ' +\
2853            'name: ' + repr(self.name) + ' ' +\
2854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2855            'tags: ' + repr(self.tags) + ' ' +\
2856            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2857            '>'
2858
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
2872
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
@classmethod
def from_dict(cls, d)
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
class AzurePostgres:
2889class AzurePostgres:
2890    __slots__ = [
2891        'bind_interface',
2892        'database',
2893        'egress_filter',
2894        'healthy',
2895        'hostname',
2896        'id',
2897        'name',
2898        'override_database',
2899        'password',
2900        'port',
2901        'port_override',
2902        'secret_store_id',
2903        'tags',
2904        'username',
2905    ]
2906
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        database=None,
2911        egress_filter=None,
2912        healthy=None,
2913        hostname=None,
2914        id=None,
2915        name=None,
2916        override_database=None,
2917        password=None,
2918        port=None,
2919        port_override=None,
2920        secret_store_id=None,
2921        tags=None,
2922        username=None,
2923    ):
2924        self.bind_interface = bind_interface if bind_interface is not None else ''
2925        '''
2926         Bind interface
2927        '''
2928        self.database = database if database is not None else ''
2929        self.egress_filter = egress_filter if egress_filter is not None else ''
2930        '''
2931         A filter applied to the routing logic to pin datasource to nodes.
2932        '''
2933        self.healthy = healthy if healthy is not None else False
2934        '''
2935         True if the datasource is reachable and the credentials are valid.
2936        '''
2937        self.hostname = hostname if hostname is not None else ''
2938        self.id = id if id is not None else ''
2939        '''
2940         Unique identifier of the Resource.
2941        '''
2942        self.name = name if name is not None else ''
2943        '''
2944         Unique human-readable name of the Resource.
2945        '''
2946        self.override_database = override_database if override_database is not None else False
2947        self.password = password if password is not None else ''
2948        self.port = port if port is not None else 0
2949        self.port_override = port_override if port_override is not None else 0
2950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2951        '''
2952         ID of the secret store containing credentials for this resource, if any.
2953        '''
2954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2955        '''
2956         Tags is a map of key, value pairs.
2957        '''
2958        self.username = username if username is not None else ''
2959
2960    def __repr__(self):
2961        return '<sdm.AzurePostgres ' + \
2962            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2963            'database: ' + repr(self.database) + ' ' +\
2964            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2965            'healthy: ' + repr(self.healthy) + ' ' +\
2966            'hostname: ' + repr(self.hostname) + ' ' +\
2967            'id: ' + repr(self.id) + ' ' +\
2968            'name: ' + repr(self.name) + ' ' +\
2969            'override_database: ' + repr(self.override_database) + ' ' +\
2970            'password: ' + repr(self.password) + ' ' +\
2971            'port: ' + repr(self.port) + ' ' +\
2972            'port_override: ' + repr(self.port_override) + ' ' +\
2973            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2974            'tags: ' + repr(self.tags) + ' ' +\
2975            'username: ' + repr(self.username) + ' ' +\
2976            '>'
2977
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'override_database': self.override_database,
2988            'password': self.password,
2989            'port': self.port,
2990            'port_override': self.port_override,
2991            'secret_store_id': self.secret_store_id,
2992            'tags': self.tags,
2993            'username': self.username,
2994        }
2995
2996    @classmethod
2997    def from_dict(cls, d):
2998        return cls(
2999            bind_interface=d.get('bind_interface'),
3000            database=d.get('database'),
3001            egress_filter=d.get('egress_filter'),
3002            healthy=d.get('healthy'),
3003            hostname=d.get('hostname'),
3004            id=d.get('id'),
3005            name=d.get('name'),
3006            override_database=d.get('override_database'),
3007            password=d.get('password'),
3008            port=d.get('port'),
3009            port_override=d.get('port_override'),
3010            secret_store_id=d.get('secret_store_id'),
3011            tags=d.get('tags'),
3012            username=d.get('username'),
3013        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        database=None,
2911        egress_filter=None,
2912        healthy=None,
2913        hostname=None,
2914        id=None,
2915        name=None,
2916        override_database=None,
2917        password=None,
2918        port=None,
2919        port_override=None,
2920        secret_store_id=None,
2921        tags=None,
2922        username=None,
2923    ):
2924        self.bind_interface = bind_interface if bind_interface is not None else ''
2925        '''
2926         Bind interface
2927        '''
2928        self.database = database if database is not None else ''
2929        self.egress_filter = egress_filter if egress_filter is not None else ''
2930        '''
2931         A filter applied to the routing logic to pin datasource to nodes.
2932        '''
2933        self.healthy = healthy if healthy is not None else False
2934        '''
2935         True if the datasource is reachable and the credentials are valid.
2936        '''
2937        self.hostname = hostname if hostname is not None else ''
2938        self.id = id if id is not None else ''
2939        '''
2940         Unique identifier of the Resource.
2941        '''
2942        self.name = name if name is not None else ''
2943        '''
2944         Unique human-readable name of the Resource.
2945        '''
2946        self.override_database = override_database if override_database is not None else False
2947        self.password = password if password is not None else ''
2948        self.port = port if port is not None else 0
2949        self.port_override = port_override if port_override is not None else 0
2950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2951        '''
2952         ID of the secret store containing credentials for this resource, if any.
2953        '''
2954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2955        '''
2956         Tags is a map of key, value pairs.
2957        '''
2958        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'override_database': self.override_database,
2988            'password': self.password,
2989            'port': self.port,
2990            'port_override': self.port_override,
2991            'secret_store_id': self.secret_store_id,
2992            'tags': self.tags,
2993            'username': self.username,
2994        }
@classmethod
def from_dict(cls, d)
2996    @classmethod
2997    def from_dict(cls, d):
2998        return cls(
2999            bind_interface=d.get('bind_interface'),
3000            database=d.get('database'),
3001            egress_filter=d.get('egress_filter'),
3002            healthy=d.get('healthy'),
3003            hostname=d.get('hostname'),
3004            id=d.get('id'),
3005            name=d.get('name'),
3006            override_database=d.get('override_database'),
3007            password=d.get('password'),
3008            port=d.get('port'),
3009            port_override=d.get('port_override'),
3010            secret_store_id=d.get('secret_store_id'),
3011            tags=d.get('tags'),
3012            username=d.get('username'),
3013        )
class AzureStore:
3016class AzureStore:
3017    __slots__ = [
3018        'id',
3019        'name',
3020        'tags',
3021        'vault_uri',
3022    ]
3023
3024    def __init__(
3025        self,
3026        id=None,
3027        name=None,
3028        tags=None,
3029        vault_uri=None,
3030    ):
3031        self.id = id if id is not None else ''
3032        '''
3033         Unique identifier of the SecretStore.
3034        '''
3035        self.name = name if name is not None else ''
3036        '''
3037         Unique human-readable name of the SecretStore.
3038        '''
3039        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3040        '''
3041         Tags is a map of key, value pairs.
3042        '''
3043        self.vault_uri = vault_uri if vault_uri is not None else ''
3044
3045    def __repr__(self):
3046        return '<sdm.AzureStore ' + \
3047            'id: ' + repr(self.id) + ' ' +\
3048            'name: ' + repr(self.name) + ' ' +\
3049            'tags: ' + repr(self.tags) + ' ' +\
3050            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3051            '>'
3052
3053    def to_dict(self):
3054        return {
3055            'id': self.id,
3056            'name': self.name,
3057            'tags': self.tags,
3058            'vault_uri': self.vault_uri,
3059        }
3060
3061    @classmethod
3062    def from_dict(cls, d):
3063        return cls(
3064            id=d.get('id'),
3065            name=d.get('name'),
3066            tags=d.get('tags'),
3067            vault_uri=d.get('vault_uri'),
3068        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3024    def __init__(
3025        self,
3026        id=None,
3027        name=None,
3028        tags=None,
3029        vault_uri=None,
3030    ):
3031        self.id = id if id is not None else ''
3032        '''
3033         Unique identifier of the SecretStore.
3034        '''
3035        self.name = name if name is not None else ''
3036        '''
3037         Unique human-readable name of the SecretStore.
3038        '''
3039        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3040        '''
3041         Tags is a map of key, value pairs.
3042        '''
3043        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3053    def to_dict(self):
3054        return {
3055            'id': self.id,
3056            'name': self.name,
3057            'tags': self.tags,
3058            'vault_uri': self.vault_uri,
3059        }
@classmethod
def from_dict(cls, d)
3061    @classmethod
3062    def from_dict(cls, d):
3063        return cls(
3064            id=d.get('id'),
3065            name=d.get('name'),
3066            tags=d.get('tags'),
3067            vault_uri=d.get('vault_uri'),
3068        )
class BigQuery:
3071class BigQuery:
3072    __slots__ = [
3073        'bind_interface',
3074        'egress_filter',
3075        'endpoint',
3076        'healthy',
3077        'id',
3078        'name',
3079        'port_override',
3080        'private_key',
3081        'project',
3082        'secret_store_id',
3083        'tags',
3084        'username',
3085    ]
3086
3087    def __init__(
3088        self,
3089        bind_interface=None,
3090        egress_filter=None,
3091        endpoint=None,
3092        healthy=None,
3093        id=None,
3094        name=None,
3095        port_override=None,
3096        private_key=None,
3097        project=None,
3098        secret_store_id=None,
3099        tags=None,
3100        username=None,
3101    ):
3102        self.bind_interface = bind_interface if bind_interface is not None else ''
3103        '''
3104         Bind interface
3105        '''
3106        self.egress_filter = egress_filter if egress_filter is not None else ''
3107        '''
3108         A filter applied to the routing logic to pin datasource to nodes.
3109        '''
3110        self.endpoint = endpoint if endpoint is not None else ''
3111        self.healthy = healthy if healthy is not None else False
3112        '''
3113         True if the datasource is reachable and the credentials are valid.
3114        '''
3115        self.id = id if id is not None else ''
3116        '''
3117         Unique identifier of the Resource.
3118        '''
3119        self.name = name if name is not None else ''
3120        '''
3121         Unique human-readable name of the Resource.
3122        '''
3123        self.port_override = port_override if port_override is not None else 0
3124        self.private_key = private_key if private_key is not None else ''
3125        self.project = project if project is not None else ''
3126        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3127        '''
3128         ID of the secret store containing credentials for this resource, if any.
3129        '''
3130        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3131        '''
3132         Tags is a map of key, value pairs.
3133        '''
3134        self.username = username if username is not None else ''
3135
3136    def __repr__(self):
3137        return '<sdm.BigQuery ' + \
3138            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3139            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3140            'endpoint: ' + repr(self.endpoint) + ' ' +\
3141            'healthy: ' + repr(self.healthy) + ' ' +\
3142            'id: ' + repr(self.id) + ' ' +\
3143            'name: ' + repr(self.name) + ' ' +\
3144            'port_override: ' + repr(self.port_override) + ' ' +\
3145            'private_key: ' + repr(self.private_key) + ' ' +\
3146            'project: ' + repr(self.project) + ' ' +\
3147            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3148            'tags: ' + repr(self.tags) + ' ' +\
3149            'username: ' + repr(self.username) + ' ' +\
3150            '>'
3151
3152    def to_dict(self):
3153        return {
3154            'bind_interface': self.bind_interface,
3155            'egress_filter': self.egress_filter,
3156            'endpoint': self.endpoint,
3157            'healthy': self.healthy,
3158            'id': self.id,
3159            'name': self.name,
3160            'port_override': self.port_override,
3161            'private_key': self.private_key,
3162            'project': self.project,
3163            'secret_store_id': self.secret_store_id,
3164            'tags': self.tags,
3165            'username': self.username,
3166        }
3167
3168    @classmethod
3169    def from_dict(cls, d):
3170        return cls(
3171            bind_interface=d.get('bind_interface'),
3172            egress_filter=d.get('egress_filter'),
3173            endpoint=d.get('endpoint'),
3174            healthy=d.get('healthy'),
3175            id=d.get('id'),
3176            name=d.get('name'),
3177            port_override=d.get('port_override'),
3178            private_key=d.get('private_key'),
3179            project=d.get('project'),
3180            secret_store_id=d.get('secret_store_id'),
3181            tags=d.get('tags'),
3182            username=d.get('username'),
3183        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3087    def __init__(
3088        self,
3089        bind_interface=None,
3090        egress_filter=None,
3091        endpoint=None,
3092        healthy=None,
3093        id=None,
3094        name=None,
3095        port_override=None,
3096        private_key=None,
3097        project=None,
3098        secret_store_id=None,
3099        tags=None,
3100        username=None,
3101    ):
3102        self.bind_interface = bind_interface if bind_interface is not None else ''
3103        '''
3104         Bind interface
3105        '''
3106        self.egress_filter = egress_filter if egress_filter is not None else ''
3107        '''
3108         A filter applied to the routing logic to pin datasource to nodes.
3109        '''
3110        self.endpoint = endpoint if endpoint is not None else ''
3111        self.healthy = healthy if healthy is not None else False
3112        '''
3113         True if the datasource is reachable and the credentials are valid.
3114        '''
3115        self.id = id if id is not None else ''
3116        '''
3117         Unique identifier of the Resource.
3118        '''
3119        self.name = name if name is not None else ''
3120        '''
3121         Unique human-readable name of the Resource.
3122        '''
3123        self.port_override = port_override if port_override is not None else 0
3124        self.private_key = private_key if private_key is not None else ''
3125        self.project = project if project is not None else ''
3126        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3127        '''
3128         ID of the secret store containing credentials for this resource, if any.
3129        '''
3130        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3131        '''
3132         Tags is a map of key, value pairs.
3133        '''
3134        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3152    def to_dict(self):
3153        return {
3154            'bind_interface': self.bind_interface,
3155            'egress_filter': self.egress_filter,
3156            'endpoint': self.endpoint,
3157            'healthy': self.healthy,
3158            'id': self.id,
3159            'name': self.name,
3160            'port_override': self.port_override,
3161            'private_key': self.private_key,
3162            'project': self.project,
3163            'secret_store_id': self.secret_store_id,
3164            'tags': self.tags,
3165            'username': self.username,
3166        }
@classmethod
def from_dict(cls, d)
3168    @classmethod
3169    def from_dict(cls, d):
3170        return cls(
3171            bind_interface=d.get('bind_interface'),
3172            egress_filter=d.get('egress_filter'),
3173            endpoint=d.get('endpoint'),
3174            healthy=d.get('healthy'),
3175            id=d.get('id'),
3176            name=d.get('name'),
3177            port_override=d.get('port_override'),
3178            private_key=d.get('private_key'),
3179            project=d.get('project'),
3180            secret_store_id=d.get('secret_store_id'),
3181            tags=d.get('tags'),
3182            username=d.get('username'),
3183        )
class Cassandra:
3186class Cassandra:
3187    __slots__ = [
3188        'bind_interface',
3189        'egress_filter',
3190        'healthy',
3191        'hostname',
3192        'id',
3193        'name',
3194        'password',
3195        'port',
3196        'port_override',
3197        'secret_store_id',
3198        'tags',
3199        'tls_required',
3200        'username',
3201    ]
3202
3203    def __init__(
3204        self,
3205        bind_interface=None,
3206        egress_filter=None,
3207        healthy=None,
3208        hostname=None,
3209        id=None,
3210        name=None,
3211        password=None,
3212        port=None,
3213        port_override=None,
3214        secret_store_id=None,
3215        tags=None,
3216        tls_required=None,
3217        username=None,
3218    ):
3219        self.bind_interface = bind_interface if bind_interface is not None else ''
3220        '''
3221         Bind interface
3222        '''
3223        self.egress_filter = egress_filter if egress_filter is not None else ''
3224        '''
3225         A filter applied to the routing logic to pin datasource to nodes.
3226        '''
3227        self.healthy = healthy if healthy is not None else False
3228        '''
3229         True if the datasource is reachable and the credentials are valid.
3230        '''
3231        self.hostname = hostname if hostname is not None else ''
3232        self.id = id if id is not None else ''
3233        '''
3234         Unique identifier of the Resource.
3235        '''
3236        self.name = name if name is not None else ''
3237        '''
3238         Unique human-readable name of the Resource.
3239        '''
3240        self.password = password if password is not None else ''
3241        self.port = port if port is not None else 0
3242        self.port_override = port_override if port_override is not None else 0
3243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3244        '''
3245         ID of the secret store containing credentials for this resource, if any.
3246        '''
3247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3248        '''
3249         Tags is a map of key, value pairs.
3250        '''
3251        self.tls_required = tls_required if tls_required is not None else False
3252        self.username = username if username is not None else ''
3253
3254    def __repr__(self):
3255        return '<sdm.Cassandra ' + \
3256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3257            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3258            'healthy: ' + repr(self.healthy) + ' ' +\
3259            'hostname: ' + repr(self.hostname) + ' ' +\
3260            'id: ' + repr(self.id) + ' ' +\
3261            'name: ' + repr(self.name) + ' ' +\
3262            'password: ' + repr(self.password) + ' ' +\
3263            'port: ' + repr(self.port) + ' ' +\
3264            'port_override: ' + repr(self.port_override) + ' ' +\
3265            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3266            'tags: ' + repr(self.tags) + ' ' +\
3267            'tls_required: ' + repr(self.tls_required) + ' ' +\
3268            'username: ' + repr(self.username) + ' ' +\
3269            '>'
3270
3271    def to_dict(self):
3272        return {
3273            'bind_interface': self.bind_interface,
3274            'egress_filter': self.egress_filter,
3275            'healthy': self.healthy,
3276            'hostname': self.hostname,
3277            'id': self.id,
3278            'name': self.name,
3279            'password': self.password,
3280            'port': self.port,
3281            'port_override': self.port_override,
3282            'secret_store_id': self.secret_store_id,
3283            'tags': self.tags,
3284            'tls_required': self.tls_required,
3285            'username': self.username,
3286        }
3287
3288    @classmethod
3289    def from_dict(cls, d):
3290        return cls(
3291            bind_interface=d.get('bind_interface'),
3292            egress_filter=d.get('egress_filter'),
3293            healthy=d.get('healthy'),
3294            hostname=d.get('hostname'),
3295            id=d.get('id'),
3296            name=d.get('name'),
3297            password=d.get('password'),
3298            port=d.get('port'),
3299            port_override=d.get('port_override'),
3300            secret_store_id=d.get('secret_store_id'),
3301            tags=d.get('tags'),
3302            tls_required=d.get('tls_required'),
3303            username=d.get('username'),
3304        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3203    def __init__(
3204        self,
3205        bind_interface=None,
3206        egress_filter=None,
3207        healthy=None,
3208        hostname=None,
3209        id=None,
3210        name=None,
3211        password=None,
3212        port=None,
3213        port_override=None,
3214        secret_store_id=None,
3215        tags=None,
3216        tls_required=None,
3217        username=None,
3218    ):
3219        self.bind_interface = bind_interface if bind_interface is not None else ''
3220        '''
3221         Bind interface
3222        '''
3223        self.egress_filter = egress_filter if egress_filter is not None else ''
3224        '''
3225         A filter applied to the routing logic to pin datasource to nodes.
3226        '''
3227        self.healthy = healthy if healthy is not None else False
3228        '''
3229         True if the datasource is reachable and the credentials are valid.
3230        '''
3231        self.hostname = hostname if hostname is not None else ''
3232        self.id = id if id is not None else ''
3233        '''
3234         Unique identifier of the Resource.
3235        '''
3236        self.name = name if name is not None else ''
3237        '''
3238         Unique human-readable name of the Resource.
3239        '''
3240        self.password = password if password is not None else ''
3241        self.port = port if port is not None else 0
3242        self.port_override = port_override if port_override is not None else 0
3243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3244        '''
3245         ID of the secret store containing credentials for this resource, if any.
3246        '''
3247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3248        '''
3249         Tags is a map of key, value pairs.
3250        '''
3251        self.tls_required = tls_required if tls_required is not None else False
3252        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3271    def to_dict(self):
3272        return {
3273            'bind_interface': self.bind_interface,
3274            'egress_filter': self.egress_filter,
3275            'healthy': self.healthy,
3276            'hostname': self.hostname,
3277            'id': self.id,
3278            'name': self.name,
3279            'password': self.password,
3280            'port': self.port,
3281            'port_override': self.port_override,
3282            'secret_store_id': self.secret_store_id,
3283            'tags': self.tags,
3284            'tls_required': self.tls_required,
3285            'username': self.username,
3286        }
@classmethod
def from_dict(cls, d)
3288    @classmethod
3289    def from_dict(cls, d):
3290        return cls(
3291            bind_interface=d.get('bind_interface'),
3292            egress_filter=d.get('egress_filter'),
3293            healthy=d.get('healthy'),
3294            hostname=d.get('hostname'),
3295            id=d.get('id'),
3296            name=d.get('name'),
3297            password=d.get('password'),
3298            port=d.get('port'),
3299            port_override=d.get('port_override'),
3300            secret_store_id=d.get('secret_store_id'),
3301            tags=d.get('tags'),
3302            tls_required=d.get('tls_required'),
3303            username=d.get('username'),
3304        )
class Citus:
3307class Citus:
3308    __slots__ = [
3309        'bind_interface',
3310        'database',
3311        'egress_filter',
3312        'healthy',
3313        'hostname',
3314        'id',
3315        'name',
3316        'override_database',
3317        'password',
3318        'port',
3319        'port_override',
3320        'secret_store_id',
3321        'tags',
3322        'username',
3323    ]
3324
3325    def __init__(
3326        self,
3327        bind_interface=None,
3328        database=None,
3329        egress_filter=None,
3330        healthy=None,
3331        hostname=None,
3332        id=None,
3333        name=None,
3334        override_database=None,
3335        password=None,
3336        port=None,
3337        port_override=None,
3338        secret_store_id=None,
3339        tags=None,
3340        username=None,
3341    ):
3342        self.bind_interface = bind_interface if bind_interface is not None else ''
3343        '''
3344         Bind interface
3345        '''
3346        self.database = database if database is not None else ''
3347        self.egress_filter = egress_filter if egress_filter is not None else ''
3348        '''
3349         A filter applied to the routing logic to pin datasource to nodes.
3350        '''
3351        self.healthy = healthy if healthy is not None else False
3352        '''
3353         True if the datasource is reachable and the credentials are valid.
3354        '''
3355        self.hostname = hostname if hostname is not None else ''
3356        self.id = id if id is not None else ''
3357        '''
3358         Unique identifier of the Resource.
3359        '''
3360        self.name = name if name is not None else ''
3361        '''
3362         Unique human-readable name of the Resource.
3363        '''
3364        self.override_database = override_database if override_database is not None else False
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.username = username if username is not None else ''
3377
3378    def __repr__(self):
3379        return '<sdm.Citus ' + \
3380            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3381            'database: ' + repr(self.database) + ' ' +\
3382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3383            'healthy: ' + repr(self.healthy) + ' ' +\
3384            'hostname: ' + repr(self.hostname) + ' ' +\
3385            'id: ' + repr(self.id) + ' ' +\
3386            'name: ' + repr(self.name) + ' ' +\
3387            'override_database: ' + repr(self.override_database) + ' ' +\
3388            'password: ' + repr(self.password) + ' ' +\
3389            'port: ' + repr(self.port) + ' ' +\
3390            'port_override: ' + repr(self.port_override) + ' ' +\
3391            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3392            'tags: ' + repr(self.tags) + ' ' +\
3393            'username: ' + repr(self.username) + ' ' +\
3394            '>'
3395
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'database': self.database,
3400            'egress_filter': self.egress_filter,
3401            'healthy': self.healthy,
3402            'hostname': self.hostname,
3403            'id': self.id,
3404            'name': self.name,
3405            'override_database': self.override_database,
3406            'password': self.password,
3407            'port': self.port,
3408            'port_override': self.port_override,
3409            'secret_store_id': self.secret_store_id,
3410            'tags': self.tags,
3411            'username': self.username,
3412        }
3413
3414    @classmethod
3415    def from_dict(cls, d):
3416        return cls(
3417            bind_interface=d.get('bind_interface'),
3418            database=d.get('database'),
3419            egress_filter=d.get('egress_filter'),
3420            healthy=d.get('healthy'),
3421            hostname=d.get('hostname'),
3422            id=d.get('id'),
3423            name=d.get('name'),
3424            override_database=d.get('override_database'),
3425            password=d.get('password'),
3426            port=d.get('port'),
3427            port_override=d.get('port_override'),
3428            secret_store_id=d.get('secret_store_id'),
3429            tags=d.get('tags'),
3430            username=d.get('username'),
3431        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3325    def __init__(
3326        self,
3327        bind_interface=None,
3328        database=None,
3329        egress_filter=None,
3330        healthy=None,
3331        hostname=None,
3332        id=None,
3333        name=None,
3334        override_database=None,
3335        password=None,
3336        port=None,
3337        port_override=None,
3338        secret_store_id=None,
3339        tags=None,
3340        username=None,
3341    ):
3342        self.bind_interface = bind_interface if bind_interface is not None else ''
3343        '''
3344         Bind interface
3345        '''
3346        self.database = database if database is not None else ''
3347        self.egress_filter = egress_filter if egress_filter is not None else ''
3348        '''
3349         A filter applied to the routing logic to pin datasource to nodes.
3350        '''
3351        self.healthy = healthy if healthy is not None else False
3352        '''
3353         True if the datasource is reachable and the credentials are valid.
3354        '''
3355        self.hostname = hostname if hostname is not None else ''
3356        self.id = id if id is not None else ''
3357        '''
3358         Unique identifier of the Resource.
3359        '''
3360        self.name = name if name is not None else ''
3361        '''
3362         Unique human-readable name of the Resource.
3363        '''
3364        self.override_database = override_database if override_database is not None else False
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'database': self.database,
3400            'egress_filter': self.egress_filter,
3401            'healthy': self.healthy,
3402            'hostname': self.hostname,
3403            'id': self.id,
3404            'name': self.name,
3405            'override_database': self.override_database,
3406            'password': self.password,
3407            'port': self.port,
3408            'port_override': self.port_override,
3409            'secret_store_id': self.secret_store_id,
3410            'tags': self.tags,
3411            'username': self.username,
3412        }
@classmethod
def from_dict(cls, d)
3414    @classmethod
3415    def from_dict(cls, d):
3416        return cls(
3417            bind_interface=d.get('bind_interface'),
3418            database=d.get('database'),
3419            egress_filter=d.get('egress_filter'),
3420            healthy=d.get('healthy'),
3421            hostname=d.get('hostname'),
3422            id=d.get('id'),
3423            name=d.get('name'),
3424            override_database=d.get('override_database'),
3425            password=d.get('password'),
3426            port=d.get('port'),
3427            port_override=d.get('port_override'),
3428            secret_store_id=d.get('secret_store_id'),
3429            tags=d.get('tags'),
3430            username=d.get('username'),
3431        )
class Clustrix:
3434class Clustrix:
3435    __slots__ = [
3436        'bind_interface',
3437        'database',
3438        'egress_filter',
3439        'healthy',
3440        'hostname',
3441        'id',
3442        'name',
3443        'password',
3444        'port',
3445        'port_override',
3446        'secret_store_id',
3447        'tags',
3448        'username',
3449    ]
3450
3451    def __init__(
3452        self,
3453        bind_interface=None,
3454        database=None,
3455        egress_filter=None,
3456        healthy=None,
3457        hostname=None,
3458        id=None,
3459        name=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.password = password if password is not None else ''
3490        self.port = port if port is not None else 0
3491        self.port_override = port_override if port_override is not None else 0
3492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3493        '''
3494         ID of the secret store containing credentials for this resource, if any.
3495        '''
3496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3497        '''
3498         Tags is a map of key, value pairs.
3499        '''
3500        self.username = username if username is not None else ''
3501
3502    def __repr__(self):
3503        return '<sdm.Clustrix ' + \
3504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3505            'database: ' + repr(self.database) + ' ' +\
3506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3507            'healthy: ' + repr(self.healthy) + ' ' +\
3508            'hostname: ' + repr(self.hostname) + ' ' +\
3509            'id: ' + repr(self.id) + ' ' +\
3510            'name: ' + repr(self.name) + ' ' +\
3511            'password: ' + repr(self.password) + ' ' +\
3512            'port: ' + repr(self.port) + ' ' +\
3513            'port_override: ' + repr(self.port_override) + ' ' +\
3514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3515            'tags: ' + repr(self.tags) + ' ' +\
3516            'username: ' + repr(self.username) + ' ' +\
3517            '>'
3518
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'password': self.password,
3529            'port': self.port,
3530            'port_override': self.port_override,
3531            'secret_store_id': self.secret_store_id,
3532            'tags': self.tags,
3533            'username': self.username,
3534        }
3535
3536    @classmethod
3537    def from_dict(cls, d):
3538        return cls(
3539            bind_interface=d.get('bind_interface'),
3540            database=d.get('database'),
3541            egress_filter=d.get('egress_filter'),
3542            healthy=d.get('healthy'),
3543            hostname=d.get('hostname'),
3544            id=d.get('id'),
3545            name=d.get('name'),
3546            password=d.get('password'),
3547            port=d.get('port'),
3548            port_override=d.get('port_override'),
3549            secret_store_id=d.get('secret_store_id'),
3550            tags=d.get('tags'),
3551            username=d.get('username'),
3552        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3451    def __init__(
3452        self,
3453        bind_interface=None,
3454        database=None,
3455        egress_filter=None,
3456        healthy=None,
3457        hostname=None,
3458        id=None,
3459        name=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.password = password if password is not None else ''
3490        self.port = port if port is not None else 0
3491        self.port_override = port_override if port_override is not None else 0
3492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3493        '''
3494         ID of the secret store containing credentials for this resource, if any.
3495        '''
3496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3497        '''
3498         Tags is a map of key, value pairs.
3499        '''
3500        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'password': self.password,
3529            'port': self.port,
3530            'port_override': self.port_override,
3531            'secret_store_id': self.secret_store_id,
3532            'tags': self.tags,
3533            'username': self.username,
3534        }
@classmethod
def from_dict(cls, d)
3536    @classmethod
3537    def from_dict(cls, d):
3538        return cls(
3539            bind_interface=d.get('bind_interface'),
3540            database=d.get('database'),
3541            egress_filter=d.get('egress_filter'),
3542            healthy=d.get('healthy'),
3543            hostname=d.get('hostname'),
3544            id=d.get('id'),
3545            name=d.get('name'),
3546            password=d.get('password'),
3547            port=d.get('port'),
3548            port_override=d.get('port_override'),
3549            secret_store_id=d.get('secret_store_id'),
3550            tags=d.get('tags'),
3551            username=d.get('username'),
3552        )
class Cockroach:
3555class Cockroach:
3556    __slots__ = [
3557        'bind_interface',
3558        'database',
3559        'egress_filter',
3560        'healthy',
3561        'hostname',
3562        'id',
3563        'name',
3564        'override_database',
3565        'password',
3566        'port',
3567        'port_override',
3568        'secret_store_id',
3569        'tags',
3570        'username',
3571    ]
3572
3573    def __init__(
3574        self,
3575        bind_interface=None,
3576        database=None,
3577        egress_filter=None,
3578        healthy=None,
3579        hostname=None,
3580        id=None,
3581        name=None,
3582        override_database=None,
3583        password=None,
3584        port=None,
3585        port_override=None,
3586        secret_store_id=None,
3587        tags=None,
3588        username=None,
3589    ):
3590        self.bind_interface = bind_interface if bind_interface is not None else ''
3591        '''
3592         Bind interface
3593        '''
3594        self.database = database if database is not None else ''
3595        self.egress_filter = egress_filter if egress_filter is not None else ''
3596        '''
3597         A filter applied to the routing logic to pin datasource to nodes.
3598        '''
3599        self.healthy = healthy if healthy is not None else False
3600        '''
3601         True if the datasource is reachable and the credentials are valid.
3602        '''
3603        self.hostname = hostname if hostname is not None else ''
3604        self.id = id if id is not None else ''
3605        '''
3606         Unique identifier of the Resource.
3607        '''
3608        self.name = name if name is not None else ''
3609        '''
3610         Unique human-readable name of the Resource.
3611        '''
3612        self.override_database = override_database if override_database is not None else False
3613        self.password = password if password is not None else ''
3614        self.port = port if port is not None else 0
3615        self.port_override = port_override if port_override is not None else 0
3616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3617        '''
3618         ID of the secret store containing credentials for this resource, if any.
3619        '''
3620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3621        '''
3622         Tags is a map of key, value pairs.
3623        '''
3624        self.username = username if username is not None else ''
3625
3626    def __repr__(self):
3627        return '<sdm.Cockroach ' + \
3628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3629            'database: ' + repr(self.database) + ' ' +\
3630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3631            'healthy: ' + repr(self.healthy) + ' ' +\
3632            'hostname: ' + repr(self.hostname) + ' ' +\
3633            'id: ' + repr(self.id) + ' ' +\
3634            'name: ' + repr(self.name) + ' ' +\
3635            'override_database: ' + repr(self.override_database) + ' ' +\
3636            'password: ' + repr(self.password) + ' ' +\
3637            'port: ' + repr(self.port) + ' ' +\
3638            'port_override: ' + repr(self.port_override) + ' ' +\
3639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3640            'tags: ' + repr(self.tags) + ' ' +\
3641            'username: ' + repr(self.username) + ' ' +\
3642            '>'
3643
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'override_database': self.override_database,
3654            'password': self.password,
3655            'port': self.port,
3656            'port_override': self.port_override,
3657            'secret_store_id': self.secret_store_id,
3658            'tags': self.tags,
3659            'username': self.username,
3660        }
3661
3662    @classmethod
3663    def from_dict(cls, d):
3664        return cls(
3665            bind_interface=d.get('bind_interface'),
3666            database=d.get('database'),
3667            egress_filter=d.get('egress_filter'),
3668            healthy=d.get('healthy'),
3669            hostname=d.get('hostname'),
3670            id=d.get('id'),
3671            name=d.get('name'),
3672            override_database=d.get('override_database'),
3673            password=d.get('password'),
3674            port=d.get('port'),
3675            port_override=d.get('port_override'),
3676            secret_store_id=d.get('secret_store_id'),
3677            tags=d.get('tags'),
3678            username=d.get('username'),
3679        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3573    def __init__(
3574        self,
3575        bind_interface=None,
3576        database=None,
3577        egress_filter=None,
3578        healthy=None,
3579        hostname=None,
3580        id=None,
3581        name=None,
3582        override_database=None,
3583        password=None,
3584        port=None,
3585        port_override=None,
3586        secret_store_id=None,
3587        tags=None,
3588        username=None,
3589    ):
3590        self.bind_interface = bind_interface if bind_interface is not None else ''
3591        '''
3592         Bind interface
3593        '''
3594        self.database = database if database is not None else ''
3595        self.egress_filter = egress_filter if egress_filter is not None else ''
3596        '''
3597         A filter applied to the routing logic to pin datasource to nodes.
3598        '''
3599        self.healthy = healthy if healthy is not None else False
3600        '''
3601         True if the datasource is reachable and the credentials are valid.
3602        '''
3603        self.hostname = hostname if hostname is not None else ''
3604        self.id = id if id is not None else ''
3605        '''
3606         Unique identifier of the Resource.
3607        '''
3608        self.name = name if name is not None else ''
3609        '''
3610         Unique human-readable name of the Resource.
3611        '''
3612        self.override_database = override_database if override_database is not None else False
3613        self.password = password if password is not None else ''
3614        self.port = port if port is not None else 0
3615        self.port_override = port_override if port_override is not None else 0
3616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3617        '''
3618         ID of the secret store containing credentials for this resource, if any.
3619        '''
3620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3621        '''
3622         Tags is a map of key, value pairs.
3623        '''
3624        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'override_database': self.override_database,
3654            'password': self.password,
3655            'port': self.port,
3656            'port_override': self.port_override,
3657            'secret_store_id': self.secret_store_id,
3658            'tags': self.tags,
3659            'username': self.username,
3660        }
@classmethod
def from_dict(cls, d)
3662    @classmethod
3663    def from_dict(cls, d):
3664        return cls(
3665            bind_interface=d.get('bind_interface'),
3666            database=d.get('database'),
3667            egress_filter=d.get('egress_filter'),
3668            healthy=d.get('healthy'),
3669            hostname=d.get('hostname'),
3670            id=d.get('id'),
3671            name=d.get('name'),
3672            override_database=d.get('override_database'),
3673            password=d.get('password'),
3674            port=d.get('port'),
3675            port_override=d.get('port_override'),
3676            secret_store_id=d.get('secret_store_id'),
3677            tags=d.get('tags'),
3678            username=d.get('username'),
3679        )
class ControlPanelGetSSHCAPublicKeyResponse:
3682class ControlPanelGetSSHCAPublicKeyResponse:
3683    '''
3684         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3685     organization's SSH Certificate Authority public key.
3686    '''
3687    __slots__ = [
3688        'meta',
3689        'public_key',
3690        'rate_limit',
3691    ]
3692
3693    def __init__(
3694        self,
3695        meta=None,
3696        public_key=None,
3697        rate_limit=None,
3698    ):
3699        self.meta = meta if meta is not None else None
3700        '''
3701         Reserved for future use.
3702        '''
3703        self.public_key = public_key if public_key is not None else ''
3704        '''
3705         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3706         key format.
3707        '''
3708        self.rate_limit = rate_limit if rate_limit is not None else None
3709        '''
3710         Rate limit information.
3711        '''
3712
3713    def __repr__(self):
3714        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3715            'meta: ' + repr(self.meta) + ' ' +\
3716            'public_key: ' + repr(self.public_key) + ' ' +\
3717            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3718            '>'
3719
3720    def to_dict(self):
3721        return {
3722            'meta': self.meta,
3723            'public_key': self.public_key,
3724            'rate_limit': self.rate_limit,
3725        }
3726
3727    @classmethod
3728    def from_dict(cls, d):
3729        return cls(
3730            meta=d.get('meta'),
3731            public_key=d.get('public_key'),
3732            rate_limit=d.get('rate_limit'),
3733        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3693    def __init__(
3694        self,
3695        meta=None,
3696        public_key=None,
3697        rate_limit=None,
3698    ):
3699        self.meta = meta if meta is not None else None
3700        '''
3701         Reserved for future use.
3702        '''
3703        self.public_key = public_key if public_key is not None else ''
3704        '''
3705         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3706         key format.
3707        '''
3708        self.rate_limit = rate_limit if rate_limit is not None else None
3709        '''
3710         Rate limit information.
3711        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3720    def to_dict(self):
3721        return {
3722            'meta': self.meta,
3723            'public_key': self.public_key,
3724            'rate_limit': self.rate_limit,
3725        }
@classmethod
def from_dict(cls, d)
3727    @classmethod
3728    def from_dict(cls, d):
3729        return cls(
3730            meta=d.get('meta'),
3731            public_key=d.get('public_key'),
3732            rate_limit=d.get('rate_limit'),
3733        )
class ControlPanelVerifyJWTResponse:
3736class ControlPanelVerifyJWTResponse:
3737    '''
3738         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3739    '''
3740    __slots__ = [
3741        'meta',
3742        'rate_limit',
3743        'valid',
3744    ]
3745
3746    def __init__(
3747        self,
3748        meta=None,
3749        rate_limit=None,
3750        valid=None,
3751    ):
3752        self.meta = meta if meta is not None else None
3753        '''
3754         Reserved for future use.
3755        '''
3756        self.rate_limit = rate_limit if rate_limit is not None else None
3757        '''
3758         Rate limit information.
3759        '''
3760        self.valid = valid if valid is not None else False
3761        '''
3762         Reports if the given token is valid.
3763        '''
3764
3765    def __repr__(self):
3766        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3767            'meta: ' + repr(self.meta) + ' ' +\
3768            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3769            'valid: ' + repr(self.valid) + ' ' +\
3770            '>'
3771
3772    def to_dict(self):
3773        return {
3774            'meta': self.meta,
3775            'rate_limit': self.rate_limit,
3776            'valid': self.valid,
3777        }
3778
3779    @classmethod
3780    def from_dict(cls, d):
3781        return cls(
3782            meta=d.get('meta'),
3783            rate_limit=d.get('rate_limit'),
3784            valid=d.get('valid'),
3785        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3746    def __init__(
3747        self,
3748        meta=None,
3749        rate_limit=None,
3750        valid=None,
3751    ):
3752        self.meta = meta if meta is not None else None
3753        '''
3754         Reserved for future use.
3755        '''
3756        self.rate_limit = rate_limit if rate_limit is not None else None
3757        '''
3758         Rate limit information.
3759        '''
3760        self.valid = valid if valid is not None else False
3761        '''
3762         Reports if the given token is valid.
3763        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3772    def to_dict(self):
3773        return {
3774            'meta': self.meta,
3775            'rate_limit': self.rate_limit,
3776            'valid': self.valid,
3777        }
@classmethod
def from_dict(cls, d)
3779    @classmethod
3780    def from_dict(cls, d):
3781        return cls(
3782            meta=d.get('meta'),
3783            rate_limit=d.get('rate_limit'),
3784            valid=d.get('valid'),
3785        )
class CreateResponseMetadata:
3788class CreateResponseMetadata:
3789    '''
3790         CreateResponseMetadata is reserved for future use.
3791    '''
3792    __slots__ = []
3793
3794    def __init__(self, ):
3795        pass
3796
3797    def __repr__(self):
3798        return '<sdm.CreateResponseMetadata ' + \
3799            '>'
3800
3801    def to_dict(self):
3802        return {}
3803
3804    @classmethod
3805    def from_dict(cls, d):
3806        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3794    def __init__(self, ):
3795        pass
def to_dict(self)
3801    def to_dict(self):
3802        return {}
@classmethod
def from_dict(cls, d)
3804    @classmethod
3805    def from_dict(cls, d):
3806        return cls()
class CyberarkConjurStore:
3809class CyberarkConjurStore:
3810    '''
3811    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
3812    without a major version bump.
3813    '''
3814    __slots__ = [
3815        'appurl',
3816        'id',
3817        'name',
3818        'tags',
3819    ]
3820
3821    def __init__(
3822        self,
3823        appurl=None,
3824        id=None,
3825        name=None,
3826        tags=None,
3827    ):
3828        self.appurl = appurl if appurl is not None else ''
3829        self.id = id if id is not None else ''
3830        '''
3831         Unique identifier of the SecretStore.
3832        '''
3833        self.name = name if name is not None else ''
3834        '''
3835         Unique human-readable name of the SecretStore.
3836        '''
3837        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3838        '''
3839         Tags is a map of key, value pairs.
3840        '''
3841
3842    def __repr__(self):
3843        return '<sdm.CyberarkConjurStore ' + \
3844            'appurl: ' + repr(self.appurl) + ' ' +\
3845            'id: ' + repr(self.id) + ' ' +\
3846            'name: ' + repr(self.name) + ' ' +\
3847            'tags: ' + repr(self.tags) + ' ' +\
3848            '>'
3849
3850    def to_dict(self):
3851        return {
3852            'appurl': self.appurl,
3853            'id': self.id,
3854            'name': self.name,
3855            'tags': self.tags,
3856        }
3857
3858    @classmethod
3859    def from_dict(cls, d):
3860        return cls(
3861            appurl=d.get('appurl'),
3862            id=d.get('id'),
3863            name=d.get('name'),
3864            tags=d.get('tags'),
3865        )

CyberarkConjurStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkConjurStore(appurl=None, id=None, name=None, tags=None)
3821    def __init__(
3822        self,
3823        appurl=None,
3824        id=None,
3825        name=None,
3826        tags=None,
3827    ):
3828        self.appurl = appurl if appurl is not None else ''
3829        self.id = id if id is not None else ''
3830        '''
3831         Unique identifier of the SecretStore.
3832        '''
3833        self.name = name if name is not None else ''
3834        '''
3835         Unique human-readable name of the SecretStore.
3836        '''
3837        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3838        '''
3839         Tags is a map of key, value pairs.
3840        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3850    def to_dict(self):
3851        return {
3852            'appurl': self.appurl,
3853            'id': self.id,
3854            'name': self.name,
3855            'tags': self.tags,
3856        }
@classmethod
def from_dict(cls, d)
3858    @classmethod
3859    def from_dict(cls, d):
3860        return cls(
3861            appurl=d.get('appurl'),
3862            id=d.get('id'),
3863            name=d.get('name'),
3864            tags=d.get('tags'),
3865        )
class CyberarkPAMExperimentalStore:
3868class CyberarkPAMExperimentalStore:
3869    '''
3870    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
3871    without a major version bump.
3872    '''
3873    __slots__ = [
3874        'appurl',
3875        'id',
3876        'name',
3877        'tags',
3878    ]
3879
3880    def __init__(
3881        self,
3882        appurl=None,
3883        id=None,
3884        name=None,
3885        tags=None,
3886    ):
3887        self.appurl = appurl if appurl is not None else ''
3888        self.id = id if id is not None else ''
3889        '''
3890         Unique identifier of the SecretStore.
3891        '''
3892        self.name = name if name is not None else ''
3893        '''
3894         Unique human-readable name of the SecretStore.
3895        '''
3896        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3897        '''
3898         Tags is a map of key, value pairs.
3899        '''
3900
3901    def __repr__(self):
3902        return '<sdm.CyberarkPAMExperimentalStore ' + \
3903            'appurl: ' + repr(self.appurl) + ' ' +\
3904            'id: ' + repr(self.id) + ' ' +\
3905            'name: ' + repr(self.name) + ' ' +\
3906            'tags: ' + repr(self.tags) + ' ' +\
3907            '>'
3908
3909    def to_dict(self):
3910        return {
3911            'appurl': self.appurl,
3912            'id': self.id,
3913            'name': self.name,
3914            'tags': self.tags,
3915        }
3916
3917    @classmethod
3918    def from_dict(cls, d):
3919        return cls(
3920            appurl=d.get('appurl'),
3921            id=d.get('id'),
3922            name=d.get('name'),
3923            tags=d.get('tags'),
3924        )

CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkPAMExperimentalStore(appurl=None, id=None, name=None, tags=None)
3880    def __init__(
3881        self,
3882        appurl=None,
3883        id=None,
3884        name=None,
3885        tags=None,
3886    ):
3887        self.appurl = appurl if appurl is not None else ''
3888        self.id = id if id is not None else ''
3889        '''
3890         Unique identifier of the SecretStore.
3891        '''
3892        self.name = name if name is not None else ''
3893        '''
3894         Unique human-readable name of the SecretStore.
3895        '''
3896        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3897        '''
3898         Tags is a map of key, value pairs.
3899        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3909    def to_dict(self):
3910        return {
3911            'appurl': self.appurl,
3912            'id': self.id,
3913            'name': self.name,
3914            'tags': self.tags,
3915        }
@classmethod
def from_dict(cls, d)
3917    @classmethod
3918    def from_dict(cls, d):
3919        return cls(
3920            appurl=d.get('appurl'),
3921            id=d.get('id'),
3922            name=d.get('name'),
3923            tags=d.get('tags'),
3924        )
class DB2I:
3927class DB2I:
3928    __slots__ = [
3929        'bind_interface',
3930        'egress_filter',
3931        'healthy',
3932        'hostname',
3933        'id',
3934        'name',
3935        'password',
3936        'port',
3937        'port_override',
3938        'secret_store_id',
3939        'tags',
3940        'tls_required',
3941        'username',
3942    ]
3943
3944    def __init__(
3945        self,
3946        bind_interface=None,
3947        egress_filter=None,
3948        healthy=None,
3949        hostname=None,
3950        id=None,
3951        name=None,
3952        password=None,
3953        port=None,
3954        port_override=None,
3955        secret_store_id=None,
3956        tags=None,
3957        tls_required=None,
3958        username=None,
3959    ):
3960        self.bind_interface = bind_interface if bind_interface is not None else ''
3961        '''
3962         Bind interface
3963        '''
3964        self.egress_filter = egress_filter if egress_filter is not None else ''
3965        '''
3966         A filter applied to the routing logic to pin datasource to nodes.
3967        '''
3968        self.healthy = healthy if healthy is not None else False
3969        '''
3970         True if the datasource is reachable and the credentials are valid.
3971        '''
3972        self.hostname = hostname if hostname is not None else ''
3973        self.id = id if id is not None else ''
3974        '''
3975         Unique identifier of the Resource.
3976        '''
3977        self.name = name if name is not None else ''
3978        '''
3979         Unique human-readable name of the Resource.
3980        '''
3981        self.password = password if password is not None else ''
3982        self.port = port if port is not None else 0
3983        self.port_override = port_override if port_override is not None else 0
3984        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3985        '''
3986         ID of the secret store containing credentials for this resource, if any.
3987        '''
3988        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3989        '''
3990         Tags is a map of key, value pairs.
3991        '''
3992        self.tls_required = tls_required if tls_required is not None else False
3993        self.username = username if username is not None else ''
3994
3995    def __repr__(self):
3996        return '<sdm.DB2I ' + \
3997            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3998            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3999            'healthy: ' + repr(self.healthy) + ' ' +\
4000            'hostname: ' + repr(self.hostname) + ' ' +\
4001            'id: ' + repr(self.id) + ' ' +\
4002            'name: ' + repr(self.name) + ' ' +\
4003            'password: ' + repr(self.password) + ' ' +\
4004            'port: ' + repr(self.port) + ' ' +\
4005            'port_override: ' + repr(self.port_override) + ' ' +\
4006            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4007            'tags: ' + repr(self.tags) + ' ' +\
4008            'tls_required: ' + repr(self.tls_required) + ' ' +\
4009            'username: ' + repr(self.username) + ' ' +\
4010            '>'
4011
4012    def to_dict(self):
4013        return {
4014            'bind_interface': self.bind_interface,
4015            'egress_filter': self.egress_filter,
4016            'healthy': self.healthy,
4017            'hostname': self.hostname,
4018            'id': self.id,
4019            'name': self.name,
4020            'password': self.password,
4021            'port': self.port,
4022            'port_override': self.port_override,
4023            'secret_store_id': self.secret_store_id,
4024            'tags': self.tags,
4025            'tls_required': self.tls_required,
4026            'username': self.username,
4027        }
4028
4029    @classmethod
4030    def from_dict(cls, d):
4031        return cls(
4032            bind_interface=d.get('bind_interface'),
4033            egress_filter=d.get('egress_filter'),
4034            healthy=d.get('healthy'),
4035            hostname=d.get('hostname'),
4036            id=d.get('id'),
4037            name=d.get('name'),
4038            password=d.get('password'),
4039            port=d.get('port'),
4040            port_override=d.get('port_override'),
4041            secret_store_id=d.get('secret_store_id'),
4042            tags=d.get('tags'),
4043            tls_required=d.get('tls_required'),
4044            username=d.get('username'),
4045        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3944    def __init__(
3945        self,
3946        bind_interface=None,
3947        egress_filter=None,
3948        healthy=None,
3949        hostname=None,
3950        id=None,
3951        name=None,
3952        password=None,
3953        port=None,
3954        port_override=None,
3955        secret_store_id=None,
3956        tags=None,
3957        tls_required=None,
3958        username=None,
3959    ):
3960        self.bind_interface = bind_interface if bind_interface is not None else ''
3961        '''
3962         Bind interface
3963        '''
3964        self.egress_filter = egress_filter if egress_filter is not None else ''
3965        '''
3966         A filter applied to the routing logic to pin datasource to nodes.
3967        '''
3968        self.healthy = healthy if healthy is not None else False
3969        '''
3970         True if the datasource is reachable and the credentials are valid.
3971        '''
3972        self.hostname = hostname if hostname is not None else ''
3973        self.id = id if id is not None else ''
3974        '''
3975         Unique identifier of the Resource.
3976        '''
3977        self.name = name if name is not None else ''
3978        '''
3979         Unique human-readable name of the Resource.
3980        '''
3981        self.password = password if password is not None else ''
3982        self.port = port if port is not None else 0
3983        self.port_override = port_override if port_override is not None else 0
3984        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3985        '''
3986         ID of the secret store containing credentials for this resource, if any.
3987        '''
3988        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3989        '''
3990         Tags is a map of key, value pairs.
3991        '''
3992        self.tls_required = tls_required if tls_required is not None else False
3993        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4012    def to_dict(self):
4013        return {
4014            'bind_interface': self.bind_interface,
4015            'egress_filter': self.egress_filter,
4016            'healthy': self.healthy,
4017            'hostname': self.hostname,
4018            'id': self.id,
4019            'name': self.name,
4020            'password': self.password,
4021            'port': self.port,
4022            'port_override': self.port_override,
4023            'secret_store_id': self.secret_store_id,
4024            'tags': self.tags,
4025            'tls_required': self.tls_required,
4026            'username': self.username,
4027        }
@classmethod
def from_dict(cls, d)
4029    @classmethod
4030    def from_dict(cls, d):
4031        return cls(
4032            bind_interface=d.get('bind_interface'),
4033            egress_filter=d.get('egress_filter'),
4034            healthy=d.get('healthy'),
4035            hostname=d.get('hostname'),
4036            id=d.get('id'),
4037            name=d.get('name'),
4038            password=d.get('password'),
4039            port=d.get('port'),
4040            port_override=d.get('port_override'),
4041            secret_store_id=d.get('secret_store_id'),
4042            tags=d.get('tags'),
4043            tls_required=d.get('tls_required'),
4044            username=d.get('username'),
4045        )
class DB2LUW:
4048class DB2LUW:
4049    __slots__ = [
4050        'bind_interface',
4051        'database',
4052        'egress_filter',
4053        'healthy',
4054        'hostname',
4055        'id',
4056        'name',
4057        'password',
4058        'port',
4059        'port_override',
4060        'secret_store_id',
4061        'tags',
4062        'username',
4063    ]
4064
4065    def __init__(
4066        self,
4067        bind_interface=None,
4068        database=None,
4069        egress_filter=None,
4070        healthy=None,
4071        hostname=None,
4072        id=None,
4073        name=None,
4074        password=None,
4075        port=None,
4076        port_override=None,
4077        secret_store_id=None,
4078        tags=None,
4079        username=None,
4080    ):
4081        self.bind_interface = bind_interface if bind_interface is not None else ''
4082        '''
4083         Bind interface
4084        '''
4085        self.database = database if database is not None else ''
4086        self.egress_filter = egress_filter if egress_filter is not None else ''
4087        '''
4088         A filter applied to the routing logic to pin datasource to nodes.
4089        '''
4090        self.healthy = healthy if healthy is not None else False
4091        '''
4092         True if the datasource is reachable and the credentials are valid.
4093        '''
4094        self.hostname = hostname if hostname is not None else ''
4095        self.id = id if id is not None else ''
4096        '''
4097         Unique identifier of the Resource.
4098        '''
4099        self.name = name if name is not None else ''
4100        '''
4101         Unique human-readable name of the Resource.
4102        '''
4103        self.password = password if password is not None else ''
4104        self.port = port if port is not None else 0
4105        self.port_override = port_override if port_override is not None else 0
4106        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4107        '''
4108         ID of the secret store containing credentials for this resource, if any.
4109        '''
4110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4111        '''
4112         Tags is a map of key, value pairs.
4113        '''
4114        self.username = username if username is not None else ''
4115
4116    def __repr__(self):
4117        return '<sdm.DB2LUW ' + \
4118            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4119            'database: ' + repr(self.database) + ' ' +\
4120            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4121            'healthy: ' + repr(self.healthy) + ' ' +\
4122            'hostname: ' + repr(self.hostname) + ' ' +\
4123            'id: ' + repr(self.id) + ' ' +\
4124            'name: ' + repr(self.name) + ' ' +\
4125            'password: ' + repr(self.password) + ' ' +\
4126            'port: ' + repr(self.port) + ' ' +\
4127            'port_override: ' + repr(self.port_override) + ' ' +\
4128            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4129            'tags: ' + repr(self.tags) + ' ' +\
4130            'username: ' + repr(self.username) + ' ' +\
4131            '>'
4132
4133    def to_dict(self):
4134        return {
4135            'bind_interface': self.bind_interface,
4136            'database': self.database,
4137            'egress_filter': self.egress_filter,
4138            'healthy': self.healthy,
4139            'hostname': self.hostname,
4140            'id': self.id,
4141            'name': self.name,
4142            'password': self.password,
4143            'port': self.port,
4144            'port_override': self.port_override,
4145            'secret_store_id': self.secret_store_id,
4146            'tags': self.tags,
4147            'username': self.username,
4148        }
4149
4150    @classmethod
4151    def from_dict(cls, d):
4152        return cls(
4153            bind_interface=d.get('bind_interface'),
4154            database=d.get('database'),
4155            egress_filter=d.get('egress_filter'),
4156            healthy=d.get('healthy'),
4157            hostname=d.get('hostname'),
4158            id=d.get('id'),
4159            name=d.get('name'),
4160            password=d.get('password'),
4161            port=d.get('port'),
4162            port_override=d.get('port_override'),
4163            secret_store_id=d.get('secret_store_id'),
4164            tags=d.get('tags'),
4165            username=d.get('username'),
4166        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4065    def __init__(
4066        self,
4067        bind_interface=None,
4068        database=None,
4069        egress_filter=None,
4070        healthy=None,
4071        hostname=None,
4072        id=None,
4073        name=None,
4074        password=None,
4075        port=None,
4076        port_override=None,
4077        secret_store_id=None,
4078        tags=None,
4079        username=None,
4080    ):
4081        self.bind_interface = bind_interface if bind_interface is not None else ''
4082        '''
4083         Bind interface
4084        '''
4085        self.database = database if database is not None else ''
4086        self.egress_filter = egress_filter if egress_filter is not None else ''
4087        '''
4088         A filter applied to the routing logic to pin datasource to nodes.
4089        '''
4090        self.healthy = healthy if healthy is not None else False
4091        '''
4092         True if the datasource is reachable and the credentials are valid.
4093        '''
4094        self.hostname = hostname if hostname is not None else ''
4095        self.id = id if id is not None else ''
4096        '''
4097         Unique identifier of the Resource.
4098        '''
4099        self.name = name if name is not None else ''
4100        '''
4101         Unique human-readable name of the Resource.
4102        '''
4103        self.password = password if password is not None else ''
4104        self.port = port if port is not None else 0
4105        self.port_override = port_override if port_override is not None else 0
4106        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4107        '''
4108         ID of the secret store containing credentials for this resource, if any.
4109        '''
4110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4111        '''
4112         Tags is a map of key, value pairs.
4113        '''
4114        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4133    def to_dict(self):
4134        return {
4135            'bind_interface': self.bind_interface,
4136            'database': self.database,
4137            'egress_filter': self.egress_filter,
4138            'healthy': self.healthy,
4139            'hostname': self.hostname,
4140            'id': self.id,
4141            'name': self.name,
4142            'password': self.password,
4143            'port': self.port,
4144            'port_override': self.port_override,
4145            'secret_store_id': self.secret_store_id,
4146            'tags': self.tags,
4147            'username': self.username,
4148        }
@classmethod
def from_dict(cls, d)
4150    @classmethod
4151    def from_dict(cls, d):
4152        return cls(
4153            bind_interface=d.get('bind_interface'),
4154            database=d.get('database'),
4155            egress_filter=d.get('egress_filter'),
4156            healthy=d.get('healthy'),
4157            hostname=d.get('hostname'),
4158            id=d.get('id'),
4159            name=d.get('name'),
4160            password=d.get('password'),
4161            port=d.get('port'),
4162            port_override=d.get('port_override'),
4163            secret_store_id=d.get('secret_store_id'),
4164            tags=d.get('tags'),
4165            username=d.get('username'),
4166        )
class DeleteResponseMetadata:
4169class DeleteResponseMetadata:
4170    '''
4171         DeleteResponseMetadata is reserved for future use.
4172    '''
4173    __slots__ = []
4174
4175    def __init__(self, ):
4176        pass
4177
4178    def __repr__(self):
4179        return '<sdm.DeleteResponseMetadata ' + \
4180            '>'
4181
4182    def to_dict(self):
4183        return {}
4184
4185    @classmethod
4186    def from_dict(cls, d):
4187        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4175    def __init__(self, ):
4176        pass
def to_dict(self)
4182    def to_dict(self):
4183        return {}
@classmethod
def from_dict(cls, d)
4185    @classmethod
4186    def from_dict(cls, d):
4187        return cls()
class DelineaStore:
4190class DelineaStore:
4191    '''
4192    DelineaStore is currently unstable, and its API may change, or it may be removed,
4193    without a major version bump.
4194    '''
4195    __slots__ = [
4196        'id',
4197        'name',
4198        'server_url',
4199        'tags',
4200        'tenant_name',
4201    ]
4202
4203    def __init__(
4204        self,
4205        id=None,
4206        name=None,
4207        server_url=None,
4208        tags=None,
4209        tenant_name=None,
4210    ):
4211        self.id = id if id is not None else ''
4212        '''
4213         Unique identifier of the SecretStore.
4214        '''
4215        self.name = name if name is not None else ''
4216        '''
4217         Unique human-readable name of the SecretStore.
4218        '''
4219        self.server_url = server_url if server_url is not None else ''
4220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4221        '''
4222         Tags is a map of key, value pairs.
4223        '''
4224        self.tenant_name = tenant_name if tenant_name is not None else ''
4225
4226    def __repr__(self):
4227        return '<sdm.DelineaStore ' + \
4228            'id: ' + repr(self.id) + ' ' +\
4229            'name: ' + repr(self.name) + ' ' +\
4230            'server_url: ' + repr(self.server_url) + ' ' +\
4231            'tags: ' + repr(self.tags) + ' ' +\
4232            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
4233            '>'
4234
4235    def to_dict(self):
4236        return {
4237            'id': self.id,
4238            'name': self.name,
4239            'server_url': self.server_url,
4240            'tags': self.tags,
4241            'tenant_name': self.tenant_name,
4242        }
4243
4244    @classmethod
4245    def from_dict(cls, d):
4246        return cls(
4247            id=d.get('id'),
4248            name=d.get('name'),
4249            server_url=d.get('server_url'),
4250            tags=d.get('tags'),
4251            tenant_name=d.get('tenant_name'),
4252        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
4203    def __init__(
4204        self,
4205        id=None,
4206        name=None,
4207        server_url=None,
4208        tags=None,
4209        tenant_name=None,
4210    ):
4211        self.id = id if id is not None else ''
4212        '''
4213         Unique identifier of the SecretStore.
4214        '''
4215        self.name = name if name is not None else ''
4216        '''
4217         Unique human-readable name of the SecretStore.
4218        '''
4219        self.server_url = server_url if server_url is not None else ''
4220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4221        '''
4222         Tags is a map of key, value pairs.
4223        '''
4224        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
4235    def to_dict(self):
4236        return {
4237            'id': self.id,
4238            'name': self.name,
4239            'server_url': self.server_url,
4240            'tags': self.tags,
4241            'tenant_name': self.tenant_name,
4242        }
@classmethod
def from_dict(cls, d)
4244    @classmethod
4245    def from_dict(cls, d):
4246        return cls(
4247            id=d.get('id'),
4248            name=d.get('name'),
4249            server_url=d.get('server_url'),
4250            tags=d.get('tags'),
4251            tenant_name=d.get('tenant_name'),
4252        )
class DocumentDBHost:
4255class DocumentDBHost:
4256    __slots__ = [
4257        'auth_database',
4258        'bind_interface',
4259        'egress_filter',
4260        'healthy',
4261        'hostname',
4262        'id',
4263        'name',
4264        'password',
4265        'port',
4266        'port_override',
4267        'secret_store_id',
4268        'tags',
4269        'username',
4270    ]
4271
4272    def __init__(
4273        self,
4274        auth_database=None,
4275        bind_interface=None,
4276        egress_filter=None,
4277        healthy=None,
4278        hostname=None,
4279        id=None,
4280        name=None,
4281        password=None,
4282        port=None,
4283        port_override=None,
4284        secret_store_id=None,
4285        tags=None,
4286        username=None,
4287    ):
4288        self.auth_database = auth_database if auth_database is not None else ''
4289        self.bind_interface = bind_interface if bind_interface is not None else ''
4290        '''
4291         Bind interface
4292        '''
4293        self.egress_filter = egress_filter if egress_filter is not None else ''
4294        '''
4295         A filter applied to the routing logic to pin datasource to nodes.
4296        '''
4297        self.healthy = healthy if healthy is not None else False
4298        '''
4299         True if the datasource is reachable and the credentials are valid.
4300        '''
4301        self.hostname = hostname if hostname is not None else ''
4302        self.id = id if id is not None else ''
4303        '''
4304         Unique identifier of the Resource.
4305        '''
4306        self.name = name if name is not None else ''
4307        '''
4308         Unique human-readable name of the Resource.
4309        '''
4310        self.password = password if password is not None else ''
4311        self.port = port if port is not None else 0
4312        self.port_override = port_override if port_override is not None else 0
4313        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4314        '''
4315         ID of the secret store containing credentials for this resource, if any.
4316        '''
4317        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4318        '''
4319         Tags is a map of key, value pairs.
4320        '''
4321        self.username = username if username is not None else ''
4322
4323    def __repr__(self):
4324        return '<sdm.DocumentDBHost ' + \
4325            'auth_database: ' + repr(self.auth_database) + ' ' +\
4326            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4327            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4328            'healthy: ' + repr(self.healthy) + ' ' +\
4329            'hostname: ' + repr(self.hostname) + ' ' +\
4330            'id: ' + repr(self.id) + ' ' +\
4331            'name: ' + repr(self.name) + ' ' +\
4332            'password: ' + repr(self.password) + ' ' +\
4333            'port: ' + repr(self.port) + ' ' +\
4334            'port_override: ' + repr(self.port_override) + ' ' +\
4335            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4336            'tags: ' + repr(self.tags) + ' ' +\
4337            'username: ' + repr(self.username) + ' ' +\
4338            '>'
4339
4340    def to_dict(self):
4341        return {
4342            'auth_database': self.auth_database,
4343            'bind_interface': self.bind_interface,
4344            'egress_filter': self.egress_filter,
4345            'healthy': self.healthy,
4346            'hostname': self.hostname,
4347            'id': self.id,
4348            'name': self.name,
4349            'password': self.password,
4350            'port': self.port,
4351            'port_override': self.port_override,
4352            'secret_store_id': self.secret_store_id,
4353            'tags': self.tags,
4354            'username': self.username,
4355        }
4356
4357    @classmethod
4358    def from_dict(cls, d):
4359        return cls(
4360            auth_database=d.get('auth_database'),
4361            bind_interface=d.get('bind_interface'),
4362            egress_filter=d.get('egress_filter'),
4363            healthy=d.get('healthy'),
4364            hostname=d.get('hostname'),
4365            id=d.get('id'),
4366            name=d.get('name'),
4367            password=d.get('password'),
4368            port=d.get('port'),
4369            port_override=d.get('port_override'),
4370            secret_store_id=d.get('secret_store_id'),
4371            tags=d.get('tags'),
4372            username=d.get('username'),
4373        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4272    def __init__(
4273        self,
4274        auth_database=None,
4275        bind_interface=None,
4276        egress_filter=None,
4277        healthy=None,
4278        hostname=None,
4279        id=None,
4280        name=None,
4281        password=None,
4282        port=None,
4283        port_override=None,
4284        secret_store_id=None,
4285        tags=None,
4286        username=None,
4287    ):
4288        self.auth_database = auth_database if auth_database is not None else ''
4289        self.bind_interface = bind_interface if bind_interface is not None else ''
4290        '''
4291         Bind interface
4292        '''
4293        self.egress_filter = egress_filter if egress_filter is not None else ''
4294        '''
4295         A filter applied to the routing logic to pin datasource to nodes.
4296        '''
4297        self.healthy = healthy if healthy is not None else False
4298        '''
4299         True if the datasource is reachable and the credentials are valid.
4300        '''
4301        self.hostname = hostname if hostname is not None else ''
4302        self.id = id if id is not None else ''
4303        '''
4304         Unique identifier of the Resource.
4305        '''
4306        self.name = name if name is not None else ''
4307        '''
4308         Unique human-readable name of the Resource.
4309        '''
4310        self.password = password if password is not None else ''
4311        self.port = port if port is not None else 0
4312        self.port_override = port_override if port_override is not None else 0
4313        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4314        '''
4315         ID of the secret store containing credentials for this resource, if any.
4316        '''
4317        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4318        '''
4319         Tags is a map of key, value pairs.
4320        '''
4321        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4340    def to_dict(self):
4341        return {
4342            'auth_database': self.auth_database,
4343            'bind_interface': self.bind_interface,
4344            'egress_filter': self.egress_filter,
4345            'healthy': self.healthy,
4346            'hostname': self.hostname,
4347            'id': self.id,
4348            'name': self.name,
4349            'password': self.password,
4350            'port': self.port,
4351            'port_override': self.port_override,
4352            'secret_store_id': self.secret_store_id,
4353            'tags': self.tags,
4354            'username': self.username,
4355        }
@classmethod
def from_dict(cls, d)
4357    @classmethod
4358    def from_dict(cls, d):
4359        return cls(
4360            auth_database=d.get('auth_database'),
4361            bind_interface=d.get('bind_interface'),
4362            egress_filter=d.get('egress_filter'),
4363            healthy=d.get('healthy'),
4364            hostname=d.get('hostname'),
4365            id=d.get('id'),
4366            name=d.get('name'),
4367            password=d.get('password'),
4368            port=d.get('port'),
4369            port_override=d.get('port_override'),
4370            secret_store_id=d.get('secret_store_id'),
4371            tags=d.get('tags'),
4372            username=d.get('username'),
4373        )
class DocumentDBReplicaSet:
4376class DocumentDBReplicaSet:
4377    __slots__ = [
4378        'auth_database',
4379        'bind_interface',
4380        'connect_to_replica',
4381        'egress_filter',
4382        'healthy',
4383        'hostname',
4384        'id',
4385        'name',
4386        'password',
4387        'port_override',
4388        'replica_set',
4389        'secret_store_id',
4390        'tags',
4391        'username',
4392    ]
4393
4394    def __init__(
4395        self,
4396        auth_database=None,
4397        bind_interface=None,
4398        connect_to_replica=None,
4399        egress_filter=None,
4400        healthy=None,
4401        hostname=None,
4402        id=None,
4403        name=None,
4404        password=None,
4405        port_override=None,
4406        replica_set=None,
4407        secret_store_id=None,
4408        tags=None,
4409        username=None,
4410    ):
4411        self.auth_database = auth_database if auth_database is not None else ''
4412        self.bind_interface = bind_interface if bind_interface is not None else ''
4413        '''
4414         Bind interface
4415        '''
4416        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4417        self.egress_filter = egress_filter if egress_filter is not None else ''
4418        '''
4419         A filter applied to the routing logic to pin datasource to nodes.
4420        '''
4421        self.healthy = healthy if healthy is not None else False
4422        '''
4423         True if the datasource is reachable and the credentials are valid.
4424        '''
4425        self.hostname = hostname if hostname is not None else ''
4426        '''
4427         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4428        '''
4429        self.id = id if id is not None else ''
4430        '''
4431         Unique identifier of the Resource.
4432        '''
4433        self.name = name if name is not None else ''
4434        '''
4435         Unique human-readable name of the Resource.
4436        '''
4437        self.password = password if password is not None else ''
4438        self.port_override = port_override if port_override is not None else 0
4439        self.replica_set = replica_set if replica_set is not None else ''
4440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4441        '''
4442         ID of the secret store containing credentials for this resource, if any.
4443        '''
4444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4445        '''
4446         Tags is a map of key, value pairs.
4447        '''
4448        self.username = username if username is not None else ''
4449
4450    def __repr__(self):
4451        return '<sdm.DocumentDBReplicaSet ' + \
4452            'auth_database: ' + repr(self.auth_database) + ' ' +\
4453            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4454            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4455            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4456            'healthy: ' + repr(self.healthy) + ' ' +\
4457            'hostname: ' + repr(self.hostname) + ' ' +\
4458            'id: ' + repr(self.id) + ' ' +\
4459            'name: ' + repr(self.name) + ' ' +\
4460            'password: ' + repr(self.password) + ' ' +\
4461            'port_override: ' + repr(self.port_override) + ' ' +\
4462            'replica_set: ' + repr(self.replica_set) + ' ' +\
4463            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4464            'tags: ' + repr(self.tags) + ' ' +\
4465            'username: ' + repr(self.username) + ' ' +\
4466            '>'
4467
4468    def to_dict(self):
4469        return {
4470            'auth_database': self.auth_database,
4471            'bind_interface': self.bind_interface,
4472            'connect_to_replica': self.connect_to_replica,
4473            'egress_filter': self.egress_filter,
4474            'healthy': self.healthy,
4475            'hostname': self.hostname,
4476            'id': self.id,
4477            'name': self.name,
4478            'password': self.password,
4479            'port_override': self.port_override,
4480            'replica_set': self.replica_set,
4481            'secret_store_id': self.secret_store_id,
4482            'tags': self.tags,
4483            'username': self.username,
4484        }
4485
4486    @classmethod
4487    def from_dict(cls, d):
4488        return cls(
4489            auth_database=d.get('auth_database'),
4490            bind_interface=d.get('bind_interface'),
4491            connect_to_replica=d.get('connect_to_replica'),
4492            egress_filter=d.get('egress_filter'),
4493            healthy=d.get('healthy'),
4494            hostname=d.get('hostname'),
4495            id=d.get('id'),
4496            name=d.get('name'),
4497            password=d.get('password'),
4498            port_override=d.get('port_override'),
4499            replica_set=d.get('replica_set'),
4500            secret_store_id=d.get('secret_store_id'),
4501            tags=d.get('tags'),
4502            username=d.get('username'),
4503        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4394    def __init__(
4395        self,
4396        auth_database=None,
4397        bind_interface=None,
4398        connect_to_replica=None,
4399        egress_filter=None,
4400        healthy=None,
4401        hostname=None,
4402        id=None,
4403        name=None,
4404        password=None,
4405        port_override=None,
4406        replica_set=None,
4407        secret_store_id=None,
4408        tags=None,
4409        username=None,
4410    ):
4411        self.auth_database = auth_database if auth_database is not None else ''
4412        self.bind_interface = bind_interface if bind_interface is not None else ''
4413        '''
4414         Bind interface
4415        '''
4416        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4417        self.egress_filter = egress_filter if egress_filter is not None else ''
4418        '''
4419         A filter applied to the routing logic to pin datasource to nodes.
4420        '''
4421        self.healthy = healthy if healthy is not None else False
4422        '''
4423         True if the datasource is reachable and the credentials are valid.
4424        '''
4425        self.hostname = hostname if hostname is not None else ''
4426        '''
4427         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4428        '''
4429        self.id = id if id is not None else ''
4430        '''
4431         Unique identifier of the Resource.
4432        '''
4433        self.name = name if name is not None else ''
4434        '''
4435         Unique human-readable name of the Resource.
4436        '''
4437        self.password = password if password is not None else ''
4438        self.port_override = port_override if port_override is not None else 0
4439        self.replica_set = replica_set if replica_set is not None else ''
4440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4441        '''
4442         ID of the secret store containing credentials for this resource, if any.
4443        '''
4444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4445        '''
4446         Tags is a map of key, value pairs.
4447        '''
4448        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4468    def to_dict(self):
4469        return {
4470            'auth_database': self.auth_database,
4471            'bind_interface': self.bind_interface,
4472            'connect_to_replica': self.connect_to_replica,
4473            'egress_filter': self.egress_filter,
4474            'healthy': self.healthy,
4475            'hostname': self.hostname,
4476            'id': self.id,
4477            'name': self.name,
4478            'password': self.password,
4479            'port_override': self.port_override,
4480            'replica_set': self.replica_set,
4481            'secret_store_id': self.secret_store_id,
4482            'tags': self.tags,
4483            'username': self.username,
4484        }
@classmethod
def from_dict(cls, d)
4486    @classmethod
4487    def from_dict(cls, d):
4488        return cls(
4489            auth_database=d.get('auth_database'),
4490            bind_interface=d.get('bind_interface'),
4491            connect_to_replica=d.get('connect_to_replica'),
4492            egress_filter=d.get('egress_filter'),
4493            healthy=d.get('healthy'),
4494            hostname=d.get('hostname'),
4495            id=d.get('id'),
4496            name=d.get('name'),
4497            password=d.get('password'),
4498            port_override=d.get('port_override'),
4499            replica_set=d.get('replica_set'),
4500            secret_store_id=d.get('secret_store_id'),
4501            tags=d.get('tags'),
4502            username=d.get('username'),
4503        )
class Druid:
4506class Druid:
4507    __slots__ = [
4508        'bind_interface',
4509        'egress_filter',
4510        'healthy',
4511        'hostname',
4512        'id',
4513        'name',
4514        'password',
4515        'port',
4516        'port_override',
4517        'secret_store_id',
4518        'tags',
4519        'username',
4520    ]
4521
4522    def __init__(
4523        self,
4524        bind_interface=None,
4525        egress_filter=None,
4526        healthy=None,
4527        hostname=None,
4528        id=None,
4529        name=None,
4530        password=None,
4531        port=None,
4532        port_override=None,
4533        secret_store_id=None,
4534        tags=None,
4535        username=None,
4536    ):
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.egress_filter = egress_filter if egress_filter is not None else ''
4542        '''
4543         A filter applied to the routing logic to pin datasource to nodes.
4544        '''
4545        self.healthy = healthy if healthy is not None else False
4546        '''
4547         True if the datasource is reachable and the credentials are valid.
4548        '''
4549        self.hostname = hostname if hostname is not None else ''
4550        self.id = id if id is not None else ''
4551        '''
4552         Unique identifier of the Resource.
4553        '''
4554        self.name = name if name is not None else ''
4555        '''
4556         Unique human-readable name of the Resource.
4557        '''
4558        self.password = password if password is not None else ''
4559        self.port = port if port is not None else 0
4560        self.port_override = port_override if port_override is not None else 0
4561        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4562        '''
4563         ID of the secret store containing credentials for this resource, if any.
4564        '''
4565        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4566        '''
4567         Tags is a map of key, value pairs.
4568        '''
4569        self.username = username if username is not None else ''
4570
4571    def __repr__(self):
4572        return '<sdm.Druid ' + \
4573            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4574            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4575            'healthy: ' + repr(self.healthy) + ' ' +\
4576            'hostname: ' + repr(self.hostname) + ' ' +\
4577            'id: ' + repr(self.id) + ' ' +\
4578            'name: ' + repr(self.name) + ' ' +\
4579            'password: ' + repr(self.password) + ' ' +\
4580            'port: ' + repr(self.port) + ' ' +\
4581            'port_override: ' + repr(self.port_override) + ' ' +\
4582            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4583            'tags: ' + repr(self.tags) + ' ' +\
4584            'username: ' + repr(self.username) + ' ' +\
4585            '>'
4586
4587    def to_dict(self):
4588        return {
4589            'bind_interface': self.bind_interface,
4590            'egress_filter': self.egress_filter,
4591            'healthy': self.healthy,
4592            'hostname': self.hostname,
4593            'id': self.id,
4594            'name': self.name,
4595            'password': self.password,
4596            'port': self.port,
4597            'port_override': self.port_override,
4598            'secret_store_id': self.secret_store_id,
4599            'tags': self.tags,
4600            'username': self.username,
4601        }
4602
4603    @classmethod
4604    def from_dict(cls, d):
4605        return cls(
4606            bind_interface=d.get('bind_interface'),
4607            egress_filter=d.get('egress_filter'),
4608            healthy=d.get('healthy'),
4609            hostname=d.get('hostname'),
4610            id=d.get('id'),
4611            name=d.get('name'),
4612            password=d.get('password'),
4613            port=d.get('port'),
4614            port_override=d.get('port_override'),
4615            secret_store_id=d.get('secret_store_id'),
4616            tags=d.get('tags'),
4617            username=d.get('username'),
4618        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4522    def __init__(
4523        self,
4524        bind_interface=None,
4525        egress_filter=None,
4526        healthy=None,
4527        hostname=None,
4528        id=None,
4529        name=None,
4530        password=None,
4531        port=None,
4532        port_override=None,
4533        secret_store_id=None,
4534        tags=None,
4535        username=None,
4536    ):
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.egress_filter = egress_filter if egress_filter is not None else ''
4542        '''
4543         A filter applied to the routing logic to pin datasource to nodes.
4544        '''
4545        self.healthy = healthy if healthy is not None else False
4546        '''
4547         True if the datasource is reachable and the credentials are valid.
4548        '''
4549        self.hostname = hostname if hostname is not None else ''
4550        self.id = id if id is not None else ''
4551        '''
4552         Unique identifier of the Resource.
4553        '''
4554        self.name = name if name is not None else ''
4555        '''
4556         Unique human-readable name of the Resource.
4557        '''
4558        self.password = password if password is not None else ''
4559        self.port = port if port is not None else 0
4560        self.port_override = port_override if port_override is not None else 0
4561        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4562        '''
4563         ID of the secret store containing credentials for this resource, if any.
4564        '''
4565        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4566        '''
4567         Tags is a map of key, value pairs.
4568        '''
4569        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4587    def to_dict(self):
4588        return {
4589            'bind_interface': self.bind_interface,
4590            'egress_filter': self.egress_filter,
4591            'healthy': self.healthy,
4592            'hostname': self.hostname,
4593            'id': self.id,
4594            'name': self.name,
4595            'password': self.password,
4596            'port': self.port,
4597            'port_override': self.port_override,
4598            'secret_store_id': self.secret_store_id,
4599            'tags': self.tags,
4600            'username': self.username,
4601        }
@classmethod
def from_dict(cls, d)
4603    @classmethod
4604    def from_dict(cls, d):
4605        return cls(
4606            bind_interface=d.get('bind_interface'),
4607            egress_filter=d.get('egress_filter'),
4608            healthy=d.get('healthy'),
4609            hostname=d.get('hostname'),
4610            id=d.get('id'),
4611            name=d.get('name'),
4612            password=d.get('password'),
4613            port=d.get('port'),
4614            port_override=d.get('port_override'),
4615            secret_store_id=d.get('secret_store_id'),
4616            tags=d.get('tags'),
4617            username=d.get('username'),
4618        )
class DynamoDB:
4621class DynamoDB:
4622    __slots__ = [
4623        'access_key',
4624        'bind_interface',
4625        'egress_filter',
4626        'endpoint',
4627        'healthy',
4628        'id',
4629        'name',
4630        'port_override',
4631        'region',
4632        'role_arn',
4633        'role_external_id',
4634        'secret_access_key',
4635        'secret_store_id',
4636        'tags',
4637    ]
4638
4639    def __init__(
4640        self,
4641        access_key=None,
4642        bind_interface=None,
4643        egress_filter=None,
4644        endpoint=None,
4645        healthy=None,
4646        id=None,
4647        name=None,
4648        port_override=None,
4649        region=None,
4650        role_arn=None,
4651        role_external_id=None,
4652        secret_access_key=None,
4653        secret_store_id=None,
4654        tags=None,
4655    ):
4656        self.access_key = access_key if access_key is not None else ''
4657        self.bind_interface = bind_interface if bind_interface is not None else ''
4658        '''
4659         Bind interface
4660        '''
4661        self.egress_filter = egress_filter if egress_filter is not None else ''
4662        '''
4663         A filter applied to the routing logic to pin datasource to nodes.
4664        '''
4665        self.endpoint = endpoint if endpoint is not None else ''
4666        self.healthy = healthy if healthy is not None else False
4667        '''
4668         True if the datasource is reachable and the credentials are valid.
4669        '''
4670        self.id = id if id is not None else ''
4671        '''
4672         Unique identifier of the Resource.
4673        '''
4674        self.name = name if name is not None else ''
4675        '''
4676         Unique human-readable name of the Resource.
4677        '''
4678        self.port_override = port_override if port_override is not None else 0
4679        self.region = region if region is not None else ''
4680        self.role_arn = role_arn if role_arn is not None else ''
4681        self.role_external_id = role_external_id if role_external_id is not None else ''
4682        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4683        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4684        '''
4685         ID of the secret store containing credentials for this resource, if any.
4686        '''
4687        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4688        '''
4689         Tags is a map of key, value pairs.
4690        '''
4691
4692    def __repr__(self):
4693        return '<sdm.DynamoDB ' + \
4694            'access_key: ' + repr(self.access_key) + ' ' +\
4695            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4696            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4697            'endpoint: ' + repr(self.endpoint) + ' ' +\
4698            'healthy: ' + repr(self.healthy) + ' ' +\
4699            'id: ' + repr(self.id) + ' ' +\
4700            'name: ' + repr(self.name) + ' ' +\
4701            'port_override: ' + repr(self.port_override) + ' ' +\
4702            'region: ' + repr(self.region) + ' ' +\
4703            'role_arn: ' + repr(self.role_arn) + ' ' +\
4704            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4705            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4706            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4707            'tags: ' + repr(self.tags) + ' ' +\
4708            '>'
4709
4710    def to_dict(self):
4711        return {
4712            'access_key': self.access_key,
4713            'bind_interface': self.bind_interface,
4714            'egress_filter': self.egress_filter,
4715            'endpoint': self.endpoint,
4716            'healthy': self.healthy,
4717            'id': self.id,
4718            'name': self.name,
4719            'port_override': self.port_override,
4720            'region': self.region,
4721            'role_arn': self.role_arn,
4722            'role_external_id': self.role_external_id,
4723            'secret_access_key': self.secret_access_key,
4724            'secret_store_id': self.secret_store_id,
4725            'tags': self.tags,
4726        }
4727
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            access_key=d.get('access_key'),
4732            bind_interface=d.get('bind_interface'),
4733            egress_filter=d.get('egress_filter'),
4734            endpoint=d.get('endpoint'),
4735            healthy=d.get('healthy'),
4736            id=d.get('id'),
4737            name=d.get('name'),
4738            port_override=d.get('port_override'),
4739            region=d.get('region'),
4740            role_arn=d.get('role_arn'),
4741            role_external_id=d.get('role_external_id'),
4742            secret_access_key=d.get('secret_access_key'),
4743            secret_store_id=d.get('secret_store_id'),
4744            tags=d.get('tags'),
4745        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4639    def __init__(
4640        self,
4641        access_key=None,
4642        bind_interface=None,
4643        egress_filter=None,
4644        endpoint=None,
4645        healthy=None,
4646        id=None,
4647        name=None,
4648        port_override=None,
4649        region=None,
4650        role_arn=None,
4651        role_external_id=None,
4652        secret_access_key=None,
4653        secret_store_id=None,
4654        tags=None,
4655    ):
4656        self.access_key = access_key if access_key is not None else ''
4657        self.bind_interface = bind_interface if bind_interface is not None else ''
4658        '''
4659         Bind interface
4660        '''
4661        self.egress_filter = egress_filter if egress_filter is not None else ''
4662        '''
4663         A filter applied to the routing logic to pin datasource to nodes.
4664        '''
4665        self.endpoint = endpoint if endpoint is not None else ''
4666        self.healthy = healthy if healthy is not None else False
4667        '''
4668         True if the datasource is reachable and the credentials are valid.
4669        '''
4670        self.id = id if id is not None else ''
4671        '''
4672         Unique identifier of the Resource.
4673        '''
4674        self.name = name if name is not None else ''
4675        '''
4676         Unique human-readable name of the Resource.
4677        '''
4678        self.port_override = port_override if port_override is not None else 0
4679        self.region = region if region is not None else ''
4680        self.role_arn = role_arn if role_arn is not None else ''
4681        self.role_external_id = role_external_id if role_external_id is not None else ''
4682        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4683        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4684        '''
4685         ID of the secret store containing credentials for this resource, if any.
4686        '''
4687        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4688        '''
4689         Tags is a map of key, value pairs.
4690        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4710    def to_dict(self):
4711        return {
4712            'access_key': self.access_key,
4713            'bind_interface': self.bind_interface,
4714            'egress_filter': self.egress_filter,
4715            'endpoint': self.endpoint,
4716            'healthy': self.healthy,
4717            'id': self.id,
4718            'name': self.name,
4719            'port_override': self.port_override,
4720            'region': self.region,
4721            'role_arn': self.role_arn,
4722            'role_external_id': self.role_external_id,
4723            'secret_access_key': self.secret_access_key,
4724            'secret_store_id': self.secret_store_id,
4725            'tags': self.tags,
4726        }
@classmethod
def from_dict(cls, d)
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            access_key=d.get('access_key'),
4732            bind_interface=d.get('bind_interface'),
4733            egress_filter=d.get('egress_filter'),
4734            endpoint=d.get('endpoint'),
4735            healthy=d.get('healthy'),
4736            id=d.get('id'),
4737            name=d.get('name'),
4738            port_override=d.get('port_override'),
4739            region=d.get('region'),
4740            role_arn=d.get('role_arn'),
4741            role_external_id=d.get('role_external_id'),
4742            secret_access_key=d.get('secret_access_key'),
4743            secret_store_id=d.get('secret_store_id'),
4744            tags=d.get('tags'),
4745        )
class Elastic:
4748class Elastic:
4749    __slots__ = [
4750        'bind_interface',
4751        'egress_filter',
4752        'healthy',
4753        'hostname',
4754        'id',
4755        'name',
4756        'password',
4757        'port',
4758        'port_override',
4759        'secret_store_id',
4760        'tags',
4761        'tls_required',
4762        'username',
4763    ]
4764
4765    def __init__(
4766        self,
4767        bind_interface=None,
4768        egress_filter=None,
4769        healthy=None,
4770        hostname=None,
4771        id=None,
4772        name=None,
4773        password=None,
4774        port=None,
4775        port_override=None,
4776        secret_store_id=None,
4777        tags=None,
4778        tls_required=None,
4779        username=None,
4780    ):
4781        self.bind_interface = bind_interface if bind_interface is not None else ''
4782        '''
4783         Bind interface
4784        '''
4785        self.egress_filter = egress_filter if egress_filter is not None else ''
4786        '''
4787         A filter applied to the routing logic to pin datasource to nodes.
4788        '''
4789        self.healthy = healthy if healthy is not None else False
4790        '''
4791         True if the datasource is reachable and the credentials are valid.
4792        '''
4793        self.hostname = hostname if hostname is not None else ''
4794        self.id = id if id is not None else ''
4795        '''
4796         Unique identifier of the Resource.
4797        '''
4798        self.name = name if name is not None else ''
4799        '''
4800         Unique human-readable name of the Resource.
4801        '''
4802        self.password = password if password is not None else ''
4803        self.port = port if port is not None else 0
4804        self.port_override = port_override if port_override is not None else 0
4805        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4806        '''
4807         ID of the secret store containing credentials for this resource, if any.
4808        '''
4809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4810        '''
4811         Tags is a map of key, value pairs.
4812        '''
4813        self.tls_required = tls_required if tls_required is not None else False
4814        self.username = username if username is not None else ''
4815
4816    def __repr__(self):
4817        return '<sdm.Elastic ' + \
4818            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4819            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4820            'healthy: ' + repr(self.healthy) + ' ' +\
4821            'hostname: ' + repr(self.hostname) + ' ' +\
4822            'id: ' + repr(self.id) + ' ' +\
4823            'name: ' + repr(self.name) + ' ' +\
4824            'password: ' + repr(self.password) + ' ' +\
4825            'port: ' + repr(self.port) + ' ' +\
4826            'port_override: ' + repr(self.port_override) + ' ' +\
4827            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4828            'tags: ' + repr(self.tags) + ' ' +\
4829            'tls_required: ' + repr(self.tls_required) + ' ' +\
4830            'username: ' + repr(self.username) + ' ' +\
4831            '>'
4832
4833    def to_dict(self):
4834        return {
4835            'bind_interface': self.bind_interface,
4836            'egress_filter': self.egress_filter,
4837            'healthy': self.healthy,
4838            'hostname': self.hostname,
4839            'id': self.id,
4840            'name': self.name,
4841            'password': self.password,
4842            'port': self.port,
4843            'port_override': self.port_override,
4844            'secret_store_id': self.secret_store_id,
4845            'tags': self.tags,
4846            'tls_required': self.tls_required,
4847            'username': self.username,
4848        }
4849
4850    @classmethod
4851    def from_dict(cls, d):
4852        return cls(
4853            bind_interface=d.get('bind_interface'),
4854            egress_filter=d.get('egress_filter'),
4855            healthy=d.get('healthy'),
4856            hostname=d.get('hostname'),
4857            id=d.get('id'),
4858            name=d.get('name'),
4859            password=d.get('password'),
4860            port=d.get('port'),
4861            port_override=d.get('port_override'),
4862            secret_store_id=d.get('secret_store_id'),
4863            tags=d.get('tags'),
4864            tls_required=d.get('tls_required'),
4865            username=d.get('username'),
4866        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4765    def __init__(
4766        self,
4767        bind_interface=None,
4768        egress_filter=None,
4769        healthy=None,
4770        hostname=None,
4771        id=None,
4772        name=None,
4773        password=None,
4774        port=None,
4775        port_override=None,
4776        secret_store_id=None,
4777        tags=None,
4778        tls_required=None,
4779        username=None,
4780    ):
4781        self.bind_interface = bind_interface if bind_interface is not None else ''
4782        '''
4783         Bind interface
4784        '''
4785        self.egress_filter = egress_filter if egress_filter is not None else ''
4786        '''
4787         A filter applied to the routing logic to pin datasource to nodes.
4788        '''
4789        self.healthy = healthy if healthy is not None else False
4790        '''
4791         True if the datasource is reachable and the credentials are valid.
4792        '''
4793        self.hostname = hostname if hostname is not None else ''
4794        self.id = id if id is not None else ''
4795        '''
4796         Unique identifier of the Resource.
4797        '''
4798        self.name = name if name is not None else ''
4799        '''
4800         Unique human-readable name of the Resource.
4801        '''
4802        self.password = password if password is not None else ''
4803        self.port = port if port is not None else 0
4804        self.port_override = port_override if port_override is not None else 0
4805        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4806        '''
4807         ID of the secret store containing credentials for this resource, if any.
4808        '''
4809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4810        '''
4811         Tags is a map of key, value pairs.
4812        '''
4813        self.tls_required = tls_required if tls_required is not None else False
4814        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4833    def to_dict(self):
4834        return {
4835            'bind_interface': self.bind_interface,
4836            'egress_filter': self.egress_filter,
4837            'healthy': self.healthy,
4838            'hostname': self.hostname,
4839            'id': self.id,
4840            'name': self.name,
4841            'password': self.password,
4842            'port': self.port,
4843            'port_override': self.port_override,
4844            'secret_store_id': self.secret_store_id,
4845            'tags': self.tags,
4846            'tls_required': self.tls_required,
4847            'username': self.username,
4848        }
@classmethod
def from_dict(cls, d)
4850    @classmethod
4851    def from_dict(cls, d):
4852        return cls(
4853            bind_interface=d.get('bind_interface'),
4854            egress_filter=d.get('egress_filter'),
4855            healthy=d.get('healthy'),
4856            hostname=d.get('hostname'),
4857            id=d.get('id'),
4858            name=d.get('name'),
4859            password=d.get('password'),
4860            port=d.get('port'),
4861            port_override=d.get('port_override'),
4862            secret_store_id=d.get('secret_store_id'),
4863            tags=d.get('tags'),
4864            tls_required=d.get('tls_required'),
4865            username=d.get('username'),
4866        )
class ElasticacheRedis:
4869class ElasticacheRedis:
4870    __slots__ = [
4871        'bind_interface',
4872        'egress_filter',
4873        'healthy',
4874        'hostname',
4875        'id',
4876        'name',
4877        'password',
4878        'port',
4879        'port_override',
4880        'secret_store_id',
4881        'tags',
4882        'tls_required',
4883    ]
4884
4885    def __init__(
4886        self,
4887        bind_interface=None,
4888        egress_filter=None,
4889        healthy=None,
4890        hostname=None,
4891        id=None,
4892        name=None,
4893        password=None,
4894        port=None,
4895        port_override=None,
4896        secret_store_id=None,
4897        tags=None,
4898        tls_required=None,
4899    ):
4900        self.bind_interface = bind_interface if bind_interface is not None else ''
4901        '''
4902         Bind interface
4903        '''
4904        self.egress_filter = egress_filter if egress_filter is not None else ''
4905        '''
4906         A filter applied to the routing logic to pin datasource to nodes.
4907        '''
4908        self.healthy = healthy if healthy is not None else False
4909        '''
4910         True if the datasource is reachable and the credentials are valid.
4911        '''
4912        self.hostname = hostname if hostname is not None else ''
4913        self.id = id if id is not None else ''
4914        '''
4915         Unique identifier of the Resource.
4916        '''
4917        self.name = name if name is not None else ''
4918        '''
4919         Unique human-readable name of the Resource.
4920        '''
4921        self.password = password if password is not None else ''
4922        self.port = port if port is not None else 0
4923        self.port_override = port_override if port_override is not None else 0
4924        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4925        '''
4926         ID of the secret store containing credentials for this resource, if any.
4927        '''
4928        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4929        '''
4930         Tags is a map of key, value pairs.
4931        '''
4932        self.tls_required = tls_required if tls_required is not None else False
4933
4934    def __repr__(self):
4935        return '<sdm.ElasticacheRedis ' + \
4936            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4937            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4938            'healthy: ' + repr(self.healthy) + ' ' +\
4939            'hostname: ' + repr(self.hostname) + ' ' +\
4940            'id: ' + repr(self.id) + ' ' +\
4941            'name: ' + repr(self.name) + ' ' +\
4942            'password: ' + repr(self.password) + ' ' +\
4943            'port: ' + repr(self.port) + ' ' +\
4944            'port_override: ' + repr(self.port_override) + ' ' +\
4945            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4946            'tags: ' + repr(self.tags) + ' ' +\
4947            'tls_required: ' + repr(self.tls_required) + ' ' +\
4948            '>'
4949
4950    def to_dict(self):
4951        return {
4952            'bind_interface': self.bind_interface,
4953            'egress_filter': self.egress_filter,
4954            'healthy': self.healthy,
4955            'hostname': self.hostname,
4956            'id': self.id,
4957            'name': self.name,
4958            'password': self.password,
4959            'port': self.port,
4960            'port_override': self.port_override,
4961            'secret_store_id': self.secret_store_id,
4962            'tags': self.tags,
4963            'tls_required': self.tls_required,
4964        }
4965
4966    @classmethod
4967    def from_dict(cls, d):
4968        return cls(
4969            bind_interface=d.get('bind_interface'),
4970            egress_filter=d.get('egress_filter'),
4971            healthy=d.get('healthy'),
4972            hostname=d.get('hostname'),
4973            id=d.get('id'),
4974            name=d.get('name'),
4975            password=d.get('password'),
4976            port=d.get('port'),
4977            port_override=d.get('port_override'),
4978            secret_store_id=d.get('secret_store_id'),
4979            tags=d.get('tags'),
4980            tls_required=d.get('tls_required'),
4981        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
4885    def __init__(
4886        self,
4887        bind_interface=None,
4888        egress_filter=None,
4889        healthy=None,
4890        hostname=None,
4891        id=None,
4892        name=None,
4893        password=None,
4894        port=None,
4895        port_override=None,
4896        secret_store_id=None,
4897        tags=None,
4898        tls_required=None,
4899    ):
4900        self.bind_interface = bind_interface if bind_interface is not None else ''
4901        '''
4902         Bind interface
4903        '''
4904        self.egress_filter = egress_filter if egress_filter is not None else ''
4905        '''
4906         A filter applied to the routing logic to pin datasource to nodes.
4907        '''
4908        self.healthy = healthy if healthy is not None else False
4909        '''
4910         True if the datasource is reachable and the credentials are valid.
4911        '''
4912        self.hostname = hostname if hostname is not None else ''
4913        self.id = id if id is not None else ''
4914        '''
4915         Unique identifier of the Resource.
4916        '''
4917        self.name = name if name is not None else ''
4918        '''
4919         Unique human-readable name of the Resource.
4920        '''
4921        self.password = password if password is not None else ''
4922        self.port = port if port is not None else 0
4923        self.port_override = port_override if port_override is not None else 0
4924        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4925        '''
4926         ID of the secret store containing credentials for this resource, if any.
4927        '''
4928        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4929        '''
4930         Tags is a map of key, value pairs.
4931        '''
4932        self.tls_required = tls_required if tls_required is not None else False
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
4950    def to_dict(self):
4951        return {
4952            'bind_interface': self.bind_interface,
4953            'egress_filter': self.egress_filter,
4954            'healthy': self.healthy,
4955            'hostname': self.hostname,
4956            'id': self.id,
4957            'name': self.name,
4958            'password': self.password,
4959            'port': self.port,
4960            'port_override': self.port_override,
4961            'secret_store_id': self.secret_store_id,
4962            'tags': self.tags,
4963            'tls_required': self.tls_required,
4964        }
@classmethod
def from_dict(cls, d)
4966    @classmethod
4967    def from_dict(cls, d):
4968        return cls(
4969            bind_interface=d.get('bind_interface'),
4970            egress_filter=d.get('egress_filter'),
4971            healthy=d.get('healthy'),
4972            hostname=d.get('hostname'),
4973            id=d.get('id'),
4974            name=d.get('name'),
4975            password=d.get('password'),
4976            port=d.get('port'),
4977            port_override=d.get('port_override'),
4978            secret_store_id=d.get('secret_store_id'),
4979            tags=d.get('tags'),
4980            tls_required=d.get('tls_required'),
4981        )
class GCP:
4984class GCP:
4985    __slots__ = [
4986        'bind_interface',
4987        'egress_filter',
4988        'healthy',
4989        'id',
4990        'keyfile',
4991        'name',
4992        'scopes',
4993        'secret_store_id',
4994        'tags',
4995    ]
4996
4997    def __init__(
4998        self,
4999        bind_interface=None,
5000        egress_filter=None,
5001        healthy=None,
5002        id=None,
5003        keyfile=None,
5004        name=None,
5005        scopes=None,
5006        secret_store_id=None,
5007        tags=None,
5008    ):
5009        self.bind_interface = bind_interface if bind_interface is not None else ''
5010        '''
5011         Bind interface
5012        '''
5013        self.egress_filter = egress_filter if egress_filter is not None else ''
5014        '''
5015         A filter applied to the routing logic to pin datasource to nodes.
5016        '''
5017        self.healthy = healthy if healthy is not None else False
5018        '''
5019         True if the datasource is reachable and the credentials are valid.
5020        '''
5021        self.id = id if id is not None else ''
5022        '''
5023         Unique identifier of the Resource.
5024        '''
5025        self.keyfile = keyfile if keyfile is not None else ''
5026        self.name = name if name is not None else ''
5027        '''
5028         Unique human-readable name of the Resource.
5029        '''
5030        self.scopes = scopes if scopes is not None else ''
5031        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5032        '''
5033         ID of the secret store containing credentials for this resource, if any.
5034        '''
5035        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5036        '''
5037         Tags is a map of key, value pairs.
5038        '''
5039
5040    def __repr__(self):
5041        return '<sdm.GCP ' + \
5042            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5043            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5044            'healthy: ' + repr(self.healthy) + ' ' +\
5045            'id: ' + repr(self.id) + ' ' +\
5046            'keyfile: ' + repr(self.keyfile) + ' ' +\
5047            'name: ' + repr(self.name) + ' ' +\
5048            'scopes: ' + repr(self.scopes) + ' ' +\
5049            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5050            'tags: ' + repr(self.tags) + ' ' +\
5051            '>'
5052
5053    def to_dict(self):
5054        return {
5055            'bind_interface': self.bind_interface,
5056            'egress_filter': self.egress_filter,
5057            'healthy': self.healthy,
5058            'id': self.id,
5059            'keyfile': self.keyfile,
5060            'name': self.name,
5061            'scopes': self.scopes,
5062            'secret_store_id': self.secret_store_id,
5063            'tags': self.tags,
5064        }
5065
5066    @classmethod
5067    def from_dict(cls, d):
5068        return cls(
5069            bind_interface=d.get('bind_interface'),
5070            egress_filter=d.get('egress_filter'),
5071            healthy=d.get('healthy'),
5072            id=d.get('id'),
5073            keyfile=d.get('keyfile'),
5074            name=d.get('name'),
5075            scopes=d.get('scopes'),
5076            secret_store_id=d.get('secret_store_id'),
5077            tags=d.get('tags'),
5078        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
4997    def __init__(
4998        self,
4999        bind_interface=None,
5000        egress_filter=None,
5001        healthy=None,
5002        id=None,
5003        keyfile=None,
5004        name=None,
5005        scopes=None,
5006        secret_store_id=None,
5007        tags=None,
5008    ):
5009        self.bind_interface = bind_interface if bind_interface is not None else ''
5010        '''
5011         Bind interface
5012        '''
5013        self.egress_filter = egress_filter if egress_filter is not None else ''
5014        '''
5015         A filter applied to the routing logic to pin datasource to nodes.
5016        '''
5017        self.healthy = healthy if healthy is not None else False
5018        '''
5019         True if the datasource is reachable and the credentials are valid.
5020        '''
5021        self.id = id if id is not None else ''
5022        '''
5023         Unique identifier of the Resource.
5024        '''
5025        self.keyfile = keyfile if keyfile is not None else ''
5026        self.name = name if name is not None else ''
5027        '''
5028         Unique human-readable name of the Resource.
5029        '''
5030        self.scopes = scopes if scopes is not None else ''
5031        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5032        '''
5033         ID of the secret store containing credentials for this resource, if any.
5034        '''
5035        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5036        '''
5037         Tags is a map of key, value pairs.
5038        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5053    def to_dict(self):
5054        return {
5055            'bind_interface': self.bind_interface,
5056            'egress_filter': self.egress_filter,
5057            'healthy': self.healthy,
5058            'id': self.id,
5059            'keyfile': self.keyfile,
5060            'name': self.name,
5061            'scopes': self.scopes,
5062            'secret_store_id': self.secret_store_id,
5063            'tags': self.tags,
5064        }
@classmethod
def from_dict(cls, d)
5066    @classmethod
5067    def from_dict(cls, d):
5068        return cls(
5069            bind_interface=d.get('bind_interface'),
5070            egress_filter=d.get('egress_filter'),
5071            healthy=d.get('healthy'),
5072            id=d.get('id'),
5073            keyfile=d.get('keyfile'),
5074            name=d.get('name'),
5075            scopes=d.get('scopes'),
5076            secret_store_id=d.get('secret_store_id'),
5077            tags=d.get('tags'),
5078        )
class GCPStore:
5081class GCPStore:
5082    __slots__ = [
5083        'id',
5084        'name',
5085        'projectid',
5086        'tags',
5087    ]
5088
5089    def __init__(
5090        self,
5091        id=None,
5092        name=None,
5093        projectid=None,
5094        tags=None,
5095    ):
5096        self.id = id if id is not None else ''
5097        '''
5098         Unique identifier of the SecretStore.
5099        '''
5100        self.name = name if name is not None else ''
5101        '''
5102         Unique human-readable name of the SecretStore.
5103        '''
5104        self.projectid = projectid if projectid is not None else ''
5105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5106        '''
5107         Tags is a map of key, value pairs.
5108        '''
5109
5110    def __repr__(self):
5111        return '<sdm.GCPStore ' + \
5112            'id: ' + repr(self.id) + ' ' +\
5113            'name: ' + repr(self.name) + ' ' +\
5114            'projectid: ' + repr(self.projectid) + ' ' +\
5115            'tags: ' + repr(self.tags) + ' ' +\
5116            '>'
5117
5118    def to_dict(self):
5119        return {
5120            'id': self.id,
5121            'name': self.name,
5122            'projectid': self.projectid,
5123            'tags': self.tags,
5124        }
5125
5126    @classmethod
5127    def from_dict(cls, d):
5128        return cls(
5129            id=d.get('id'),
5130            name=d.get('name'),
5131            projectid=d.get('projectid'),
5132            tags=d.get('tags'),
5133        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5089    def __init__(
5090        self,
5091        id=None,
5092        name=None,
5093        projectid=None,
5094        tags=None,
5095    ):
5096        self.id = id if id is not None else ''
5097        '''
5098         Unique identifier of the SecretStore.
5099        '''
5100        self.name = name if name is not None else ''
5101        '''
5102         Unique human-readable name of the SecretStore.
5103        '''
5104        self.projectid = projectid if projectid is not None else ''
5105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5106        '''
5107         Tags is a map of key, value pairs.
5108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5118    def to_dict(self):
5119        return {
5120            'id': self.id,
5121            'name': self.name,
5122            'projectid': self.projectid,
5123            'tags': self.tags,
5124        }
@classmethod
def from_dict(cls, d)
5126    @classmethod
5127    def from_dict(cls, d):
5128        return cls(
5129            id=d.get('id'),
5130            name=d.get('name'),
5131            projectid=d.get('projectid'),
5132            tags=d.get('tags'),
5133        )
class Gateway:
5136class Gateway:
5137    '''
5138         Gateway represents a StrongDM CLI installation running in gateway mode.
5139    '''
5140    __slots__ = [
5141        'bind_address',
5142        'gateway_filter',
5143        'id',
5144        'listen_address',
5145        'name',
5146        'state',
5147        'tags',
5148    ]
5149
5150    def __init__(
5151        self,
5152        bind_address=None,
5153        gateway_filter=None,
5154        id=None,
5155        listen_address=None,
5156        name=None,
5157        state=None,
5158        tags=None,
5159    ):
5160        self.bind_address = bind_address if bind_address is not None else ''
5161        '''
5162         The hostname/port tuple which the gateway daemon will bind to.
5163         If not provided on create, set to "0.0.0.0:listen_address_port".
5164        '''
5165        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5166        '''
5167         GatewayFilter can be used to restrict the peering between relays and
5168         gateways.
5169        '''
5170        self.id = id if id is not None else ''
5171        '''
5172         Unique identifier of the Gateway.
5173        '''
5174        self.listen_address = listen_address if listen_address is not None else ''
5175        '''
5176         The public hostname/port tuple at which the gateway will be accessible to clients.
5177        '''
5178        self.name = name if name is not None else ''
5179        '''
5180         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5181        '''
5182        self.state = state if state is not None else ''
5183        '''
5184         The current state of the gateway. One of: "new", "verifying_restart",
5185         "restarting", "started", "stopped", "dead", "unknown"
5186        '''
5187        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5188        '''
5189         Tags is a map of key, value pairs.
5190        '''
5191
5192    def __repr__(self):
5193        return '<sdm.Gateway ' + \
5194            'bind_address: ' + repr(self.bind_address) + ' ' +\
5195            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5196            'id: ' + repr(self.id) + ' ' +\
5197            'listen_address: ' + repr(self.listen_address) + ' ' +\
5198            'name: ' + repr(self.name) + ' ' +\
5199            'state: ' + repr(self.state) + ' ' +\
5200            'tags: ' + repr(self.tags) + ' ' +\
5201            '>'
5202
5203    def to_dict(self):
5204        return {
5205            'bind_address': self.bind_address,
5206            'gateway_filter': self.gateway_filter,
5207            'id': self.id,
5208            'listen_address': self.listen_address,
5209            'name': self.name,
5210            'state': self.state,
5211            'tags': self.tags,
5212        }
5213
5214    @classmethod
5215    def from_dict(cls, d):
5216        return cls(
5217            bind_address=d.get('bind_address'),
5218            gateway_filter=d.get('gateway_filter'),
5219            id=d.get('id'),
5220            listen_address=d.get('listen_address'),
5221            name=d.get('name'),
5222            state=d.get('state'),
5223            tags=d.get('tags'),
5224        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
5150    def __init__(
5151        self,
5152        bind_address=None,
5153        gateway_filter=None,
5154        id=None,
5155        listen_address=None,
5156        name=None,
5157        state=None,
5158        tags=None,
5159    ):
5160        self.bind_address = bind_address if bind_address is not None else ''
5161        '''
5162         The hostname/port tuple which the gateway daemon will bind to.
5163         If not provided on create, set to "0.0.0.0:listen_address_port".
5164        '''
5165        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5166        '''
5167         GatewayFilter can be used to restrict the peering between relays and
5168         gateways.
5169        '''
5170        self.id = id if id is not None else ''
5171        '''
5172         Unique identifier of the Gateway.
5173        '''
5174        self.listen_address = listen_address if listen_address is not None else ''
5175        '''
5176         The public hostname/port tuple at which the gateway will be accessible to clients.
5177        '''
5178        self.name = name if name is not None else ''
5179        '''
5180         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5181        '''
5182        self.state = state if state is not None else ''
5183        '''
5184         The current state of the gateway. One of: "new", "verifying_restart",
5185         "restarting", "started", "stopped", "dead", "unknown"
5186        '''
5187        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5188        '''
5189         Tags is a map of key, value pairs.
5190        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
5203    def to_dict(self):
5204        return {
5205            'bind_address': self.bind_address,
5206            'gateway_filter': self.gateway_filter,
5207            'id': self.id,
5208            'listen_address': self.listen_address,
5209            'name': self.name,
5210            'state': self.state,
5211            'tags': self.tags,
5212        }
@classmethod
def from_dict(cls, d)
5214    @classmethod
5215    def from_dict(cls, d):
5216        return cls(
5217            bind_address=d.get('bind_address'),
5218            gateway_filter=d.get('gateway_filter'),
5219            id=d.get('id'),
5220            listen_address=d.get('listen_address'),
5221            name=d.get('name'),
5222            state=d.get('state'),
5223            tags=d.get('tags'),
5224        )
class GetResponseMetadata:
5227class GetResponseMetadata:
5228    '''
5229         GetResponseMetadata is reserved for future use.
5230    '''
5231    __slots__ = []
5232
5233    def __init__(self, ):
5234        pass
5235
5236    def __repr__(self):
5237        return '<sdm.GetResponseMetadata ' + \
5238            '>'
5239
5240    def to_dict(self):
5241        return {}
5242
5243    @classmethod
5244    def from_dict(cls, d):
5245        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5233    def __init__(self, ):
5234        pass
def to_dict(self)
5240    def to_dict(self):
5241        return {}
@classmethod
def from_dict(cls, d)
5243    @classmethod
5244    def from_dict(cls, d):
5245        return cls()
class GoogleGKE:
5248class GoogleGKE:
5249    __slots__ = [
5250        'bind_interface',
5251        'certificate_authority',
5252        'egress_filter',
5253        'endpoint',
5254        'healthcheck_namespace',
5255        'healthy',
5256        'id',
5257        'name',
5258        'remote_identity_group_id',
5259        'remote_identity_healthcheck_username',
5260        'secret_store_id',
5261        'service_account_key',
5262        'tags',
5263    ]
5264
5265    def __init__(
5266        self,
5267        bind_interface=None,
5268        certificate_authority=None,
5269        egress_filter=None,
5270        endpoint=None,
5271        healthcheck_namespace=None,
5272        healthy=None,
5273        id=None,
5274        name=None,
5275        remote_identity_group_id=None,
5276        remote_identity_healthcheck_username=None,
5277        secret_store_id=None,
5278        service_account_key=None,
5279        tags=None,
5280    ):
5281        self.bind_interface = bind_interface if bind_interface is not None else ''
5282        '''
5283         Bind interface
5284        '''
5285        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5286        self.egress_filter = egress_filter if egress_filter is not None else ''
5287        '''
5288         A filter applied to the routing logic to pin datasource to nodes.
5289        '''
5290        self.endpoint = endpoint if endpoint is not None else ''
5291        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5292        '''
5293         The path used to check the health of your connection.  Defaults to `default`.
5294        '''
5295        self.healthy = healthy if healthy is not None else False
5296        '''
5297         True if the datasource is reachable and the credentials are valid.
5298        '''
5299        self.id = id if id is not None else ''
5300        '''
5301         Unique identifier of the Resource.
5302        '''
5303        self.name = name if name is not None else ''
5304        '''
5305         Unique human-readable name of the Resource.
5306        '''
5307        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5308        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5309        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5310        '''
5311         ID of the secret store containing credentials for this resource, if any.
5312        '''
5313        self.service_account_key = service_account_key if service_account_key is not None else ''
5314        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5315        '''
5316         Tags is a map of key, value pairs.
5317        '''
5318
5319    def __repr__(self):
5320        return '<sdm.GoogleGKE ' + \
5321            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5322            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5323            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5324            'endpoint: ' + repr(self.endpoint) + ' ' +\
5325            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5326            'healthy: ' + repr(self.healthy) + ' ' +\
5327            'id: ' + repr(self.id) + ' ' +\
5328            'name: ' + repr(self.name) + ' ' +\
5329            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5330            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5331            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5332            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5333            'tags: ' + repr(self.tags) + ' ' +\
5334            '>'
5335
5336    def to_dict(self):
5337        return {
5338            'bind_interface': self.bind_interface,
5339            'certificate_authority': self.certificate_authority,
5340            'egress_filter': self.egress_filter,
5341            'endpoint': self.endpoint,
5342            'healthcheck_namespace': self.healthcheck_namespace,
5343            'healthy': self.healthy,
5344            'id': self.id,
5345            'name': self.name,
5346            'remote_identity_group_id': self.remote_identity_group_id,
5347            'remote_identity_healthcheck_username':
5348            self.remote_identity_healthcheck_username,
5349            'secret_store_id': self.secret_store_id,
5350            'service_account_key': self.service_account_key,
5351            'tags': self.tags,
5352        }
5353
5354    @classmethod
5355    def from_dict(cls, d):
5356        return cls(
5357            bind_interface=d.get('bind_interface'),
5358            certificate_authority=d.get('certificate_authority'),
5359            egress_filter=d.get('egress_filter'),
5360            endpoint=d.get('endpoint'),
5361            healthcheck_namespace=d.get('healthcheck_namespace'),
5362            healthy=d.get('healthy'),
5363            id=d.get('id'),
5364            name=d.get('name'),
5365            remote_identity_group_id=d.get('remote_identity_group_id'),
5366            remote_identity_healthcheck_username=d.get(
5367                'remote_identity_healthcheck_username'),
5368            secret_store_id=d.get('secret_store_id'),
5369            service_account_key=d.get('service_account_key'),
5370            tags=d.get('tags'),
5371        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5265    def __init__(
5266        self,
5267        bind_interface=None,
5268        certificate_authority=None,
5269        egress_filter=None,
5270        endpoint=None,
5271        healthcheck_namespace=None,
5272        healthy=None,
5273        id=None,
5274        name=None,
5275        remote_identity_group_id=None,
5276        remote_identity_healthcheck_username=None,
5277        secret_store_id=None,
5278        service_account_key=None,
5279        tags=None,
5280    ):
5281        self.bind_interface = bind_interface if bind_interface is not None else ''
5282        '''
5283         Bind interface
5284        '''
5285        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5286        self.egress_filter = egress_filter if egress_filter is not None else ''
5287        '''
5288         A filter applied to the routing logic to pin datasource to nodes.
5289        '''
5290        self.endpoint = endpoint if endpoint is not None else ''
5291        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5292        '''
5293         The path used to check the health of your connection.  Defaults to `default`.
5294        '''
5295        self.healthy = healthy if healthy is not None else False
5296        '''
5297         True if the datasource is reachable and the credentials are valid.
5298        '''
5299        self.id = id if id is not None else ''
5300        '''
5301         Unique identifier of the Resource.
5302        '''
5303        self.name = name if name is not None else ''
5304        '''
5305         Unique human-readable name of the Resource.
5306        '''
5307        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5308        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5309        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5310        '''
5311         ID of the secret store containing credentials for this resource, if any.
5312        '''
5313        self.service_account_key = service_account_key if service_account_key is not None else ''
5314        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5315        '''
5316         Tags is a map of key, value pairs.
5317        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5336    def to_dict(self):
5337        return {
5338            'bind_interface': self.bind_interface,
5339            'certificate_authority': self.certificate_authority,
5340            'egress_filter': self.egress_filter,
5341            'endpoint': self.endpoint,
5342            'healthcheck_namespace': self.healthcheck_namespace,
5343            'healthy': self.healthy,
5344            'id': self.id,
5345            'name': self.name,
5346            'remote_identity_group_id': self.remote_identity_group_id,
5347            'remote_identity_healthcheck_username':
5348            self.remote_identity_healthcheck_username,
5349            'secret_store_id': self.secret_store_id,
5350            'service_account_key': self.service_account_key,
5351            'tags': self.tags,
5352        }
@classmethod
def from_dict(cls, d)
5354    @classmethod
5355    def from_dict(cls, d):
5356        return cls(
5357            bind_interface=d.get('bind_interface'),
5358            certificate_authority=d.get('certificate_authority'),
5359            egress_filter=d.get('egress_filter'),
5360            endpoint=d.get('endpoint'),
5361            healthcheck_namespace=d.get('healthcheck_namespace'),
5362            healthy=d.get('healthy'),
5363            id=d.get('id'),
5364            name=d.get('name'),
5365            remote_identity_group_id=d.get('remote_identity_group_id'),
5366            remote_identity_healthcheck_username=d.get(
5367                'remote_identity_healthcheck_username'),
5368            secret_store_id=d.get('secret_store_id'),
5369            service_account_key=d.get('service_account_key'),
5370            tags=d.get('tags'),
5371        )
class GoogleGKEUserImpersonation:
5374class GoogleGKEUserImpersonation:
5375    __slots__ = [
5376        'bind_interface',
5377        'certificate_authority',
5378        'egress_filter',
5379        'endpoint',
5380        'healthcheck_namespace',
5381        'healthy',
5382        'id',
5383        'name',
5384        'secret_store_id',
5385        'service_account_key',
5386        'tags',
5387    ]
5388
5389    def __init__(
5390        self,
5391        bind_interface=None,
5392        certificate_authority=None,
5393        egress_filter=None,
5394        endpoint=None,
5395        healthcheck_namespace=None,
5396        healthy=None,
5397        id=None,
5398        name=None,
5399        secret_store_id=None,
5400        service_account_key=None,
5401        tags=None,
5402    ):
5403        self.bind_interface = bind_interface if bind_interface is not None else ''
5404        '''
5405         Bind interface
5406        '''
5407        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5408        self.egress_filter = egress_filter if egress_filter is not None else ''
5409        '''
5410         A filter applied to the routing logic to pin datasource to nodes.
5411        '''
5412        self.endpoint = endpoint if endpoint is not None else ''
5413        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5414        '''
5415         The path used to check the health of your connection.  Defaults to `default`.
5416        '''
5417        self.healthy = healthy if healthy is not None else False
5418        '''
5419         True if the datasource is reachable and the credentials are valid.
5420        '''
5421        self.id = id if id is not None else ''
5422        '''
5423         Unique identifier of the Resource.
5424        '''
5425        self.name = name if name is not None else ''
5426        '''
5427         Unique human-readable name of the Resource.
5428        '''
5429        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5430        '''
5431         ID of the secret store containing credentials for this resource, if any.
5432        '''
5433        self.service_account_key = service_account_key if service_account_key is not None else ''
5434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5435        '''
5436         Tags is a map of key, value pairs.
5437        '''
5438
5439    def __repr__(self):
5440        return '<sdm.GoogleGKEUserImpersonation ' + \
5441            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5442            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5443            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5444            'endpoint: ' + repr(self.endpoint) + ' ' +\
5445            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5446            'healthy: ' + repr(self.healthy) + ' ' +\
5447            'id: ' + repr(self.id) + ' ' +\
5448            'name: ' + repr(self.name) + ' ' +\
5449            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5450            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5451            'tags: ' + repr(self.tags) + ' ' +\
5452            '>'
5453
5454    def to_dict(self):
5455        return {
5456            'bind_interface': self.bind_interface,
5457            'certificate_authority': self.certificate_authority,
5458            'egress_filter': self.egress_filter,
5459            'endpoint': self.endpoint,
5460            'healthcheck_namespace': self.healthcheck_namespace,
5461            'healthy': self.healthy,
5462            'id': self.id,
5463            'name': self.name,
5464            'secret_store_id': self.secret_store_id,
5465            'service_account_key': self.service_account_key,
5466            'tags': self.tags,
5467        }
5468
5469    @classmethod
5470    def from_dict(cls, d):
5471        return cls(
5472            bind_interface=d.get('bind_interface'),
5473            certificate_authority=d.get('certificate_authority'),
5474            egress_filter=d.get('egress_filter'),
5475            endpoint=d.get('endpoint'),
5476            healthcheck_namespace=d.get('healthcheck_namespace'),
5477            healthy=d.get('healthy'),
5478            id=d.get('id'),
5479            name=d.get('name'),
5480            secret_store_id=d.get('secret_store_id'),
5481            service_account_key=d.get('service_account_key'),
5482            tags=d.get('tags'),
5483        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5389    def __init__(
5390        self,
5391        bind_interface=None,
5392        certificate_authority=None,
5393        egress_filter=None,
5394        endpoint=None,
5395        healthcheck_namespace=None,
5396        healthy=None,
5397        id=None,
5398        name=None,
5399        secret_store_id=None,
5400        service_account_key=None,
5401        tags=None,
5402    ):
5403        self.bind_interface = bind_interface if bind_interface is not None else ''
5404        '''
5405         Bind interface
5406        '''
5407        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5408        self.egress_filter = egress_filter if egress_filter is not None else ''
5409        '''
5410         A filter applied to the routing logic to pin datasource to nodes.
5411        '''
5412        self.endpoint = endpoint if endpoint is not None else ''
5413        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5414        '''
5415         The path used to check the health of your connection.  Defaults to `default`.
5416        '''
5417        self.healthy = healthy if healthy is not None else False
5418        '''
5419         True if the datasource is reachable and the credentials are valid.
5420        '''
5421        self.id = id if id is not None else ''
5422        '''
5423         Unique identifier of the Resource.
5424        '''
5425        self.name = name if name is not None else ''
5426        '''
5427         Unique human-readable name of the Resource.
5428        '''
5429        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5430        '''
5431         ID of the secret store containing credentials for this resource, if any.
5432        '''
5433        self.service_account_key = service_account_key if service_account_key is not None else ''
5434        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5435        '''
5436         Tags is a map of key, value pairs.
5437        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5454    def to_dict(self):
5455        return {
5456            'bind_interface': self.bind_interface,
5457            'certificate_authority': self.certificate_authority,
5458            'egress_filter': self.egress_filter,
5459            'endpoint': self.endpoint,
5460            'healthcheck_namespace': self.healthcheck_namespace,
5461            'healthy': self.healthy,
5462            'id': self.id,
5463            'name': self.name,
5464            'secret_store_id': self.secret_store_id,
5465            'service_account_key': self.service_account_key,
5466            'tags': self.tags,
5467        }
@classmethod
def from_dict(cls, d)
5469    @classmethod
5470    def from_dict(cls, d):
5471        return cls(
5472            bind_interface=d.get('bind_interface'),
5473            certificate_authority=d.get('certificate_authority'),
5474            egress_filter=d.get('egress_filter'),
5475            endpoint=d.get('endpoint'),
5476            healthcheck_namespace=d.get('healthcheck_namespace'),
5477            healthy=d.get('healthy'),
5478            id=d.get('id'),
5479            name=d.get('name'),
5480            secret_store_id=d.get('secret_store_id'),
5481            service_account_key=d.get('service_account_key'),
5482            tags=d.get('tags'),
5483        )
class Greenplum:
5486class Greenplum:
5487    __slots__ = [
5488        'bind_interface',
5489        'database',
5490        'egress_filter',
5491        'healthy',
5492        'hostname',
5493        'id',
5494        'name',
5495        'override_database',
5496        'password',
5497        'port',
5498        'port_override',
5499        'secret_store_id',
5500        'tags',
5501        'username',
5502    ]
5503
5504    def __init__(
5505        self,
5506        bind_interface=None,
5507        database=None,
5508        egress_filter=None,
5509        healthy=None,
5510        hostname=None,
5511        id=None,
5512        name=None,
5513        override_database=None,
5514        password=None,
5515        port=None,
5516        port_override=None,
5517        secret_store_id=None,
5518        tags=None,
5519        username=None,
5520    ):
5521        self.bind_interface = bind_interface if bind_interface is not None else ''
5522        '''
5523         Bind interface
5524        '''
5525        self.database = database if database is not None else ''
5526        self.egress_filter = egress_filter if egress_filter is not None else ''
5527        '''
5528         A filter applied to the routing logic to pin datasource to nodes.
5529        '''
5530        self.healthy = healthy if healthy is not None else False
5531        '''
5532         True if the datasource is reachable and the credentials are valid.
5533        '''
5534        self.hostname = hostname if hostname is not None else ''
5535        self.id = id if id is not None else ''
5536        '''
5537         Unique identifier of the Resource.
5538        '''
5539        self.name = name if name is not None else ''
5540        '''
5541         Unique human-readable name of the Resource.
5542        '''
5543        self.override_database = override_database if override_database is not None else False
5544        self.password = password if password is not None else ''
5545        self.port = port if port is not None else 0
5546        self.port_override = port_override if port_override is not None else 0
5547        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5548        '''
5549         ID of the secret store containing credentials for this resource, if any.
5550        '''
5551        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5552        '''
5553         Tags is a map of key, value pairs.
5554        '''
5555        self.username = username if username is not None else ''
5556
5557    def __repr__(self):
5558        return '<sdm.Greenplum ' + \
5559            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5560            'database: ' + repr(self.database) + ' ' +\
5561            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5562            'healthy: ' + repr(self.healthy) + ' ' +\
5563            'hostname: ' + repr(self.hostname) + ' ' +\
5564            'id: ' + repr(self.id) + ' ' +\
5565            'name: ' + repr(self.name) + ' ' +\
5566            'override_database: ' + repr(self.override_database) + ' ' +\
5567            'password: ' + repr(self.password) + ' ' +\
5568            'port: ' + repr(self.port) + ' ' +\
5569            'port_override: ' + repr(self.port_override) + ' ' +\
5570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5571            'tags: ' + repr(self.tags) + ' ' +\
5572            'username: ' + repr(self.username) + ' ' +\
5573            '>'
5574
5575    def to_dict(self):
5576        return {
5577            'bind_interface': self.bind_interface,
5578            'database': self.database,
5579            'egress_filter': self.egress_filter,
5580            'healthy': self.healthy,
5581            'hostname': self.hostname,
5582            'id': self.id,
5583            'name': self.name,
5584            'override_database': self.override_database,
5585            'password': self.password,
5586            'port': self.port,
5587            'port_override': self.port_override,
5588            'secret_store_id': self.secret_store_id,
5589            'tags': self.tags,
5590            'username': self.username,
5591        }
5592
5593    @classmethod
5594    def from_dict(cls, d):
5595        return cls(
5596            bind_interface=d.get('bind_interface'),
5597            database=d.get('database'),
5598            egress_filter=d.get('egress_filter'),
5599            healthy=d.get('healthy'),
5600            hostname=d.get('hostname'),
5601            id=d.get('id'),
5602            name=d.get('name'),
5603            override_database=d.get('override_database'),
5604            password=d.get('password'),
5605            port=d.get('port'),
5606            port_override=d.get('port_override'),
5607            secret_store_id=d.get('secret_store_id'),
5608            tags=d.get('tags'),
5609            username=d.get('username'),
5610        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5504    def __init__(
5505        self,
5506        bind_interface=None,
5507        database=None,
5508        egress_filter=None,
5509        healthy=None,
5510        hostname=None,
5511        id=None,
5512        name=None,
5513        override_database=None,
5514        password=None,
5515        port=None,
5516        port_override=None,
5517        secret_store_id=None,
5518        tags=None,
5519        username=None,
5520    ):
5521        self.bind_interface = bind_interface if bind_interface is not None else ''
5522        '''
5523         Bind interface
5524        '''
5525        self.database = database if database is not None else ''
5526        self.egress_filter = egress_filter if egress_filter is not None else ''
5527        '''
5528         A filter applied to the routing logic to pin datasource to nodes.
5529        '''
5530        self.healthy = healthy if healthy is not None else False
5531        '''
5532         True if the datasource is reachable and the credentials are valid.
5533        '''
5534        self.hostname = hostname if hostname is not None else ''
5535        self.id = id if id is not None else ''
5536        '''
5537         Unique identifier of the Resource.
5538        '''
5539        self.name = name if name is not None else ''
5540        '''
5541         Unique human-readable name of the Resource.
5542        '''
5543        self.override_database = override_database if override_database is not None else False
5544        self.password = password if password is not None else ''
5545        self.port = port if port is not None else 0
5546        self.port_override = port_override if port_override is not None else 0
5547        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5548        '''
5549         ID of the secret store containing credentials for this resource, if any.
5550        '''
5551        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5552        '''
5553         Tags is a map of key, value pairs.
5554        '''
5555        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5575    def to_dict(self):
5576        return {
5577            'bind_interface': self.bind_interface,
5578            'database': self.database,
5579            'egress_filter': self.egress_filter,
5580            'healthy': self.healthy,
5581            'hostname': self.hostname,
5582            'id': self.id,
5583            'name': self.name,
5584            'override_database': self.override_database,
5585            'password': self.password,
5586            'port': self.port,
5587            'port_override': self.port_override,
5588            'secret_store_id': self.secret_store_id,
5589            'tags': self.tags,
5590            'username': self.username,
5591        }
@classmethod
def from_dict(cls, d)
5593    @classmethod
5594    def from_dict(cls, d):
5595        return cls(
5596            bind_interface=d.get('bind_interface'),
5597            database=d.get('database'),
5598            egress_filter=d.get('egress_filter'),
5599            healthy=d.get('healthy'),
5600            hostname=d.get('hostname'),
5601            id=d.get('id'),
5602            name=d.get('name'),
5603            override_database=d.get('override_database'),
5604            password=d.get('password'),
5605            port=d.get('port'),
5606            port_override=d.get('port_override'),
5607            secret_store_id=d.get('secret_store_id'),
5608            tags=d.get('tags'),
5609            username=d.get('username'),
5610        )
class HTTPAuth:
5613class HTTPAuth:
5614    __slots__ = [
5615        'auth_header',
5616        'bind_interface',
5617        'default_path',
5618        'egress_filter',
5619        'headers_blacklist',
5620        'healthcheck_path',
5621        'healthy',
5622        'host_override',
5623        'id',
5624        'name',
5625        'secret_store_id',
5626        'subdomain',
5627        'tags',
5628        'url',
5629    ]
5630
5631    def __init__(
5632        self,
5633        auth_header=None,
5634        bind_interface=None,
5635        default_path=None,
5636        egress_filter=None,
5637        headers_blacklist=None,
5638        healthcheck_path=None,
5639        healthy=None,
5640        host_override=None,
5641        id=None,
5642        name=None,
5643        secret_store_id=None,
5644        subdomain=None,
5645        tags=None,
5646        url=None,
5647    ):
5648        self.auth_header = auth_header if auth_header is not None else ''
5649        self.bind_interface = bind_interface if bind_interface is not None else ''
5650        '''
5651         Bind interface
5652        '''
5653        self.default_path = default_path if default_path is not None else ''
5654        self.egress_filter = egress_filter if egress_filter is not None else ''
5655        '''
5656         A filter applied to the routing logic to pin datasource to nodes.
5657        '''
5658        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5659        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5660        self.healthy = healthy if healthy is not None else False
5661        '''
5662         True if the datasource is reachable and the credentials are valid.
5663        '''
5664        self.host_override = host_override if host_override is not None else ''
5665        self.id = id if id is not None else ''
5666        '''
5667         Unique identifier of the Resource.
5668        '''
5669        self.name = name if name is not None else ''
5670        '''
5671         Unique human-readable name of the Resource.
5672        '''
5673        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5674        '''
5675         ID of the secret store containing credentials for this resource, if any.
5676        '''
5677        self.subdomain = subdomain if subdomain is not None else ''
5678        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5679        '''
5680         Tags is a map of key, value pairs.
5681        '''
5682        self.url = url if url is not None else ''
5683
5684    def __repr__(self):
5685        return '<sdm.HTTPAuth ' + \
5686            'auth_header: ' + repr(self.auth_header) + ' ' +\
5687            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5688            'default_path: ' + repr(self.default_path) + ' ' +\
5689            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5690            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5691            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5692            'healthy: ' + repr(self.healthy) + ' ' +\
5693            'host_override: ' + repr(self.host_override) + ' ' +\
5694            'id: ' + repr(self.id) + ' ' +\
5695            'name: ' + repr(self.name) + ' ' +\
5696            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5697            'subdomain: ' + repr(self.subdomain) + ' ' +\
5698            'tags: ' + repr(self.tags) + ' ' +\
5699            'url: ' + repr(self.url) + ' ' +\
5700            '>'
5701
5702    def to_dict(self):
5703        return {
5704            'auth_header': self.auth_header,
5705            'bind_interface': self.bind_interface,
5706            'default_path': self.default_path,
5707            'egress_filter': self.egress_filter,
5708            'headers_blacklist': self.headers_blacklist,
5709            'healthcheck_path': self.healthcheck_path,
5710            'healthy': self.healthy,
5711            'host_override': self.host_override,
5712            'id': self.id,
5713            'name': self.name,
5714            'secret_store_id': self.secret_store_id,
5715            'subdomain': self.subdomain,
5716            'tags': self.tags,
5717            'url': self.url,
5718        }
5719
5720    @classmethod
5721    def from_dict(cls, d):
5722        return cls(
5723            auth_header=d.get('auth_header'),
5724            bind_interface=d.get('bind_interface'),
5725            default_path=d.get('default_path'),
5726            egress_filter=d.get('egress_filter'),
5727            headers_blacklist=d.get('headers_blacklist'),
5728            healthcheck_path=d.get('healthcheck_path'),
5729            healthy=d.get('healthy'),
5730            host_override=d.get('host_override'),
5731            id=d.get('id'),
5732            name=d.get('name'),
5733            secret_store_id=d.get('secret_store_id'),
5734            subdomain=d.get('subdomain'),
5735            tags=d.get('tags'),
5736            url=d.get('url'),
5737        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5631    def __init__(
5632        self,
5633        auth_header=None,
5634        bind_interface=None,
5635        default_path=None,
5636        egress_filter=None,
5637        headers_blacklist=None,
5638        healthcheck_path=None,
5639        healthy=None,
5640        host_override=None,
5641        id=None,
5642        name=None,
5643        secret_store_id=None,
5644        subdomain=None,
5645        tags=None,
5646        url=None,
5647    ):
5648        self.auth_header = auth_header if auth_header is not None else ''
5649        self.bind_interface = bind_interface if bind_interface is not None else ''
5650        '''
5651         Bind interface
5652        '''
5653        self.default_path = default_path if default_path is not None else ''
5654        self.egress_filter = egress_filter if egress_filter is not None else ''
5655        '''
5656         A filter applied to the routing logic to pin datasource to nodes.
5657        '''
5658        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5659        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5660        self.healthy = healthy if healthy is not None else False
5661        '''
5662         True if the datasource is reachable and the credentials are valid.
5663        '''
5664        self.host_override = host_override if host_override is not None else ''
5665        self.id = id if id is not None else ''
5666        '''
5667         Unique identifier of the Resource.
5668        '''
5669        self.name = name if name is not None else ''
5670        '''
5671         Unique human-readable name of the Resource.
5672        '''
5673        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5674        '''
5675         ID of the secret store containing credentials for this resource, if any.
5676        '''
5677        self.subdomain = subdomain if subdomain is not None else ''
5678        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5679        '''
5680         Tags is a map of key, value pairs.
5681        '''
5682        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5702    def to_dict(self):
5703        return {
5704            'auth_header': self.auth_header,
5705            'bind_interface': self.bind_interface,
5706            'default_path': self.default_path,
5707            'egress_filter': self.egress_filter,
5708            'headers_blacklist': self.headers_blacklist,
5709            'healthcheck_path': self.healthcheck_path,
5710            'healthy': self.healthy,
5711            'host_override': self.host_override,
5712            'id': self.id,
5713            'name': self.name,
5714            'secret_store_id': self.secret_store_id,
5715            'subdomain': self.subdomain,
5716            'tags': self.tags,
5717            'url': self.url,
5718        }
@classmethod
def from_dict(cls, d)
5720    @classmethod
5721    def from_dict(cls, d):
5722        return cls(
5723            auth_header=d.get('auth_header'),
5724            bind_interface=d.get('bind_interface'),
5725            default_path=d.get('default_path'),
5726            egress_filter=d.get('egress_filter'),
5727            headers_blacklist=d.get('headers_blacklist'),
5728            healthcheck_path=d.get('healthcheck_path'),
5729            healthy=d.get('healthy'),
5730            host_override=d.get('host_override'),
5731            id=d.get('id'),
5732            name=d.get('name'),
5733            secret_store_id=d.get('secret_store_id'),
5734            subdomain=d.get('subdomain'),
5735            tags=d.get('tags'),
5736            url=d.get('url'),
5737        )
class HTTPBasicAuth:
5740class HTTPBasicAuth:
5741    __slots__ = [
5742        'bind_interface',
5743        'default_path',
5744        'egress_filter',
5745        'headers_blacklist',
5746        'healthcheck_path',
5747        'healthy',
5748        'host_override',
5749        'id',
5750        'name',
5751        'password',
5752        'secret_store_id',
5753        'subdomain',
5754        'tags',
5755        'url',
5756        'username',
5757    ]
5758
5759    def __init__(
5760        self,
5761        bind_interface=None,
5762        default_path=None,
5763        egress_filter=None,
5764        headers_blacklist=None,
5765        healthcheck_path=None,
5766        healthy=None,
5767        host_override=None,
5768        id=None,
5769        name=None,
5770        password=None,
5771        secret_store_id=None,
5772        subdomain=None,
5773        tags=None,
5774        url=None,
5775        username=None,
5776    ):
5777        self.bind_interface = bind_interface if bind_interface is not None else ''
5778        '''
5779         Bind interface
5780        '''
5781        self.default_path = default_path if default_path is not None else ''
5782        self.egress_filter = egress_filter if egress_filter is not None else ''
5783        '''
5784         A filter applied to the routing logic to pin datasource to nodes.
5785        '''
5786        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5787        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5788        self.healthy = healthy if healthy is not None else False
5789        '''
5790         True if the datasource is reachable and the credentials are valid.
5791        '''
5792        self.host_override = host_override if host_override is not None else ''
5793        self.id = id if id is not None else ''
5794        '''
5795         Unique identifier of the Resource.
5796        '''
5797        self.name = name if name is not None else ''
5798        '''
5799         Unique human-readable name of the Resource.
5800        '''
5801        self.password = password if password is not None else ''
5802        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5803        '''
5804         ID of the secret store containing credentials for this resource, if any.
5805        '''
5806        self.subdomain = subdomain if subdomain is not None else ''
5807        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5808        '''
5809         Tags is a map of key, value pairs.
5810        '''
5811        self.url = url if url is not None else ''
5812        self.username = username if username is not None else ''
5813
5814    def __repr__(self):
5815        return '<sdm.HTTPBasicAuth ' + \
5816            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5817            'default_path: ' + repr(self.default_path) + ' ' +\
5818            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5819            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5820            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5821            'healthy: ' + repr(self.healthy) + ' ' +\
5822            'host_override: ' + repr(self.host_override) + ' ' +\
5823            'id: ' + repr(self.id) + ' ' +\
5824            'name: ' + repr(self.name) + ' ' +\
5825            'password: ' + repr(self.password) + ' ' +\
5826            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5827            'subdomain: ' + repr(self.subdomain) + ' ' +\
5828            'tags: ' + repr(self.tags) + ' ' +\
5829            'url: ' + repr(self.url) + ' ' +\
5830            'username: ' + repr(self.username) + ' ' +\
5831            '>'
5832
5833    def to_dict(self):
5834        return {
5835            'bind_interface': self.bind_interface,
5836            'default_path': self.default_path,
5837            'egress_filter': self.egress_filter,
5838            'headers_blacklist': self.headers_blacklist,
5839            'healthcheck_path': self.healthcheck_path,
5840            'healthy': self.healthy,
5841            'host_override': self.host_override,
5842            'id': self.id,
5843            'name': self.name,
5844            'password': self.password,
5845            'secret_store_id': self.secret_store_id,
5846            'subdomain': self.subdomain,
5847            'tags': self.tags,
5848            'url': self.url,
5849            'username': self.username,
5850        }
5851
5852    @classmethod
5853    def from_dict(cls, d):
5854        return cls(
5855            bind_interface=d.get('bind_interface'),
5856            default_path=d.get('default_path'),
5857            egress_filter=d.get('egress_filter'),
5858            headers_blacklist=d.get('headers_blacklist'),
5859            healthcheck_path=d.get('healthcheck_path'),
5860            healthy=d.get('healthy'),
5861            host_override=d.get('host_override'),
5862            id=d.get('id'),
5863            name=d.get('name'),
5864            password=d.get('password'),
5865            secret_store_id=d.get('secret_store_id'),
5866            subdomain=d.get('subdomain'),
5867            tags=d.get('tags'),
5868            url=d.get('url'),
5869            username=d.get('username'),
5870        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5759    def __init__(
5760        self,
5761        bind_interface=None,
5762        default_path=None,
5763        egress_filter=None,
5764        headers_blacklist=None,
5765        healthcheck_path=None,
5766        healthy=None,
5767        host_override=None,
5768        id=None,
5769        name=None,
5770        password=None,
5771        secret_store_id=None,
5772        subdomain=None,
5773        tags=None,
5774        url=None,
5775        username=None,
5776    ):
5777        self.bind_interface = bind_interface if bind_interface is not None else ''
5778        '''
5779         Bind interface
5780        '''
5781        self.default_path = default_path if default_path is not None else ''
5782        self.egress_filter = egress_filter if egress_filter is not None else ''
5783        '''
5784         A filter applied to the routing logic to pin datasource to nodes.
5785        '''
5786        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5787        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5788        self.healthy = healthy if healthy is not None else False
5789        '''
5790         True if the datasource is reachable and the credentials are valid.
5791        '''
5792        self.host_override = host_override if host_override is not None else ''
5793        self.id = id if id is not None else ''
5794        '''
5795         Unique identifier of the Resource.
5796        '''
5797        self.name = name if name is not None else ''
5798        '''
5799         Unique human-readable name of the Resource.
5800        '''
5801        self.password = password if password is not None else ''
5802        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5803        '''
5804         ID of the secret store containing credentials for this resource, if any.
5805        '''
5806        self.subdomain = subdomain if subdomain is not None else ''
5807        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5808        '''
5809         Tags is a map of key, value pairs.
5810        '''
5811        self.url = url if url is not None else ''
5812        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
5833    def to_dict(self):
5834        return {
5835            'bind_interface': self.bind_interface,
5836            'default_path': self.default_path,
5837            'egress_filter': self.egress_filter,
5838            'headers_blacklist': self.headers_blacklist,
5839            'healthcheck_path': self.healthcheck_path,
5840            'healthy': self.healthy,
5841            'host_override': self.host_override,
5842            'id': self.id,
5843            'name': self.name,
5844            'password': self.password,
5845            'secret_store_id': self.secret_store_id,
5846            'subdomain': self.subdomain,
5847            'tags': self.tags,
5848            'url': self.url,
5849            'username': self.username,
5850        }
@classmethod
def from_dict(cls, d)
5852    @classmethod
5853    def from_dict(cls, d):
5854        return cls(
5855            bind_interface=d.get('bind_interface'),
5856            default_path=d.get('default_path'),
5857            egress_filter=d.get('egress_filter'),
5858            headers_blacklist=d.get('headers_blacklist'),
5859            healthcheck_path=d.get('healthcheck_path'),
5860            healthy=d.get('healthy'),
5861            host_override=d.get('host_override'),
5862            id=d.get('id'),
5863            name=d.get('name'),
5864            password=d.get('password'),
5865            secret_store_id=d.get('secret_store_id'),
5866            subdomain=d.get('subdomain'),
5867            tags=d.get('tags'),
5868            url=d.get('url'),
5869            username=d.get('username'),
5870        )
class HTTPNoAuth:
5873class HTTPNoAuth:
5874    __slots__ = [
5875        'bind_interface',
5876        'default_path',
5877        'egress_filter',
5878        'headers_blacklist',
5879        'healthcheck_path',
5880        'healthy',
5881        'host_override',
5882        'id',
5883        'name',
5884        'secret_store_id',
5885        'subdomain',
5886        'tags',
5887        'url',
5888    ]
5889
5890    def __init__(
5891        self,
5892        bind_interface=None,
5893        default_path=None,
5894        egress_filter=None,
5895        headers_blacklist=None,
5896        healthcheck_path=None,
5897        healthy=None,
5898        host_override=None,
5899        id=None,
5900        name=None,
5901        secret_store_id=None,
5902        subdomain=None,
5903        tags=None,
5904        url=None,
5905    ):
5906        self.bind_interface = bind_interface if bind_interface is not None else ''
5907        '''
5908         Bind interface
5909        '''
5910        self.default_path = default_path if default_path is not None else ''
5911        self.egress_filter = egress_filter if egress_filter is not None else ''
5912        '''
5913         A filter applied to the routing logic to pin datasource to nodes.
5914        '''
5915        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5916        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5917        self.healthy = healthy if healthy is not None else False
5918        '''
5919         True if the datasource is reachable and the credentials are valid.
5920        '''
5921        self.host_override = host_override if host_override is not None else ''
5922        self.id = id if id is not None else ''
5923        '''
5924         Unique identifier of the Resource.
5925        '''
5926        self.name = name if name is not None else ''
5927        '''
5928         Unique human-readable name of the Resource.
5929        '''
5930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5931        '''
5932         ID of the secret store containing credentials for this resource, if any.
5933        '''
5934        self.subdomain = subdomain if subdomain is not None else ''
5935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5936        '''
5937         Tags is a map of key, value pairs.
5938        '''
5939        self.url = url if url is not None else ''
5940
5941    def __repr__(self):
5942        return '<sdm.HTTPNoAuth ' + \
5943            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5944            'default_path: ' + repr(self.default_path) + ' ' +\
5945            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5946            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5947            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5948            'healthy: ' + repr(self.healthy) + ' ' +\
5949            'host_override: ' + repr(self.host_override) + ' ' +\
5950            'id: ' + repr(self.id) + ' ' +\
5951            'name: ' + repr(self.name) + ' ' +\
5952            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5953            'subdomain: ' + repr(self.subdomain) + ' ' +\
5954            'tags: ' + repr(self.tags) + ' ' +\
5955            'url: ' + repr(self.url) + ' ' +\
5956            '>'
5957
5958    def to_dict(self):
5959        return {
5960            'bind_interface': self.bind_interface,
5961            'default_path': self.default_path,
5962            'egress_filter': self.egress_filter,
5963            'headers_blacklist': self.headers_blacklist,
5964            'healthcheck_path': self.healthcheck_path,
5965            'healthy': self.healthy,
5966            'host_override': self.host_override,
5967            'id': self.id,
5968            'name': self.name,
5969            'secret_store_id': self.secret_store_id,
5970            'subdomain': self.subdomain,
5971            'tags': self.tags,
5972            'url': self.url,
5973        }
5974
5975    @classmethod
5976    def from_dict(cls, d):
5977        return cls(
5978            bind_interface=d.get('bind_interface'),
5979            default_path=d.get('default_path'),
5980            egress_filter=d.get('egress_filter'),
5981            headers_blacklist=d.get('headers_blacklist'),
5982            healthcheck_path=d.get('healthcheck_path'),
5983            healthy=d.get('healthy'),
5984            host_override=d.get('host_override'),
5985            id=d.get('id'),
5986            name=d.get('name'),
5987            secret_store_id=d.get('secret_store_id'),
5988            subdomain=d.get('subdomain'),
5989            tags=d.get('tags'),
5990            url=d.get('url'),
5991        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5890    def __init__(
5891        self,
5892        bind_interface=None,
5893        default_path=None,
5894        egress_filter=None,
5895        headers_blacklist=None,
5896        healthcheck_path=None,
5897        healthy=None,
5898        host_override=None,
5899        id=None,
5900        name=None,
5901        secret_store_id=None,
5902        subdomain=None,
5903        tags=None,
5904        url=None,
5905    ):
5906        self.bind_interface = bind_interface if bind_interface is not None else ''
5907        '''
5908         Bind interface
5909        '''
5910        self.default_path = default_path if default_path is not None else ''
5911        self.egress_filter = egress_filter if egress_filter is not None else ''
5912        '''
5913         A filter applied to the routing logic to pin datasource to nodes.
5914        '''
5915        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5916        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5917        self.healthy = healthy if healthy is not None else False
5918        '''
5919         True if the datasource is reachable and the credentials are valid.
5920        '''
5921        self.host_override = host_override if host_override is not None else ''
5922        self.id = id if id is not None else ''
5923        '''
5924         Unique identifier of the Resource.
5925        '''
5926        self.name = name if name is not None else ''
5927        '''
5928         Unique human-readable name of the Resource.
5929        '''
5930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5931        '''
5932         ID of the secret store containing credentials for this resource, if any.
5933        '''
5934        self.subdomain = subdomain if subdomain is not None else ''
5935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5936        '''
5937         Tags is a map of key, value pairs.
5938        '''
5939        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5958    def to_dict(self):
5959        return {
5960            'bind_interface': self.bind_interface,
5961            'default_path': self.default_path,
5962            'egress_filter': self.egress_filter,
5963            'headers_blacklist': self.headers_blacklist,
5964            'healthcheck_path': self.healthcheck_path,
5965            'healthy': self.healthy,
5966            'host_override': self.host_override,
5967            'id': self.id,
5968            'name': self.name,
5969            'secret_store_id': self.secret_store_id,
5970            'subdomain': self.subdomain,
5971            'tags': self.tags,
5972            'url': self.url,
5973        }
@classmethod
def from_dict(cls, d)
5975    @classmethod
5976    def from_dict(cls, d):
5977        return cls(
5978            bind_interface=d.get('bind_interface'),
5979            default_path=d.get('default_path'),
5980            egress_filter=d.get('egress_filter'),
5981            headers_blacklist=d.get('headers_blacklist'),
5982            healthcheck_path=d.get('healthcheck_path'),
5983            healthy=d.get('healthy'),
5984            host_override=d.get('host_override'),
5985            id=d.get('id'),
5986            name=d.get('name'),
5987            secret_store_id=d.get('secret_store_id'),
5988            subdomain=d.get('subdomain'),
5989            tags=d.get('tags'),
5990            url=d.get('url'),
5991        )
class Kubernetes:
5994class Kubernetes:
5995    __slots__ = [
5996        'bind_interface',
5997        'certificate_authority',
5998        'client_certificate',
5999        'client_key',
6000        'egress_filter',
6001        'healthcheck_namespace',
6002        'healthy',
6003        'hostname',
6004        'id',
6005        'name',
6006        'port',
6007        'port_override',
6008        'remote_identity_group_id',
6009        'remote_identity_healthcheck_username',
6010        'secret_store_id',
6011        'tags',
6012    ]
6013
6014    def __init__(
6015        self,
6016        bind_interface=None,
6017        certificate_authority=None,
6018        client_certificate=None,
6019        client_key=None,
6020        egress_filter=None,
6021        healthcheck_namespace=None,
6022        healthy=None,
6023        hostname=None,
6024        id=None,
6025        name=None,
6026        port=None,
6027        port_override=None,
6028        remote_identity_group_id=None,
6029        remote_identity_healthcheck_username=None,
6030        secret_store_id=None,
6031        tags=None,
6032    ):
6033        self.bind_interface = bind_interface if bind_interface is not None else ''
6034        '''
6035         Bind interface
6036        '''
6037        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6038        self.client_certificate = client_certificate if client_certificate is not None else ''
6039        self.client_key = client_key if client_key is not None else ''
6040        self.egress_filter = egress_filter if egress_filter is not None else ''
6041        '''
6042         A filter applied to the routing logic to pin datasource to nodes.
6043        '''
6044        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6045        '''
6046         The path used to check the health of your connection.  Defaults to `default`.
6047        '''
6048        self.healthy = healthy if healthy is not None else False
6049        '''
6050         True if the datasource is reachable and the credentials are valid.
6051        '''
6052        self.hostname = hostname if hostname is not None else ''
6053        self.id = id if id is not None else ''
6054        '''
6055         Unique identifier of the Resource.
6056        '''
6057        self.name = name if name is not None else ''
6058        '''
6059         Unique human-readable name of the Resource.
6060        '''
6061        self.port = port if port is not None else 0
6062        self.port_override = port_override if port_override is not None else 0
6063        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6064        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6065        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6066        '''
6067         ID of the secret store containing credentials for this resource, if any.
6068        '''
6069        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6070        '''
6071         Tags is a map of key, value pairs.
6072        '''
6073
6074    def __repr__(self):
6075        return '<sdm.Kubernetes ' + \
6076            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6077            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6078            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6079            'client_key: ' + repr(self.client_key) + ' ' +\
6080            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6081            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6082            'healthy: ' + repr(self.healthy) + ' ' +\
6083            'hostname: ' + repr(self.hostname) + ' ' +\
6084            'id: ' + repr(self.id) + ' ' +\
6085            'name: ' + repr(self.name) + ' ' +\
6086            'port: ' + repr(self.port) + ' ' +\
6087            'port_override: ' + repr(self.port_override) + ' ' +\
6088            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6089            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6090            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6091            'tags: ' + repr(self.tags) + ' ' +\
6092            '>'
6093
6094    def to_dict(self):
6095        return {
6096            'bind_interface': self.bind_interface,
6097            'certificate_authority': self.certificate_authority,
6098            'client_certificate': self.client_certificate,
6099            'client_key': self.client_key,
6100            'egress_filter': self.egress_filter,
6101            'healthcheck_namespace': self.healthcheck_namespace,
6102            'healthy': self.healthy,
6103            'hostname': self.hostname,
6104            'id': self.id,
6105            'name': self.name,
6106            'port': self.port,
6107            'port_override': self.port_override,
6108            'remote_identity_group_id': self.remote_identity_group_id,
6109            'remote_identity_healthcheck_username':
6110            self.remote_identity_healthcheck_username,
6111            'secret_store_id': self.secret_store_id,
6112            'tags': self.tags,
6113        }
6114
6115    @classmethod
6116    def from_dict(cls, d):
6117        return cls(
6118            bind_interface=d.get('bind_interface'),
6119            certificate_authority=d.get('certificate_authority'),
6120            client_certificate=d.get('client_certificate'),
6121            client_key=d.get('client_key'),
6122            egress_filter=d.get('egress_filter'),
6123            healthcheck_namespace=d.get('healthcheck_namespace'),
6124            healthy=d.get('healthy'),
6125            hostname=d.get('hostname'),
6126            id=d.get('id'),
6127            name=d.get('name'),
6128            port=d.get('port'),
6129            port_override=d.get('port_override'),
6130            remote_identity_group_id=d.get('remote_identity_group_id'),
6131            remote_identity_healthcheck_username=d.get(
6132                'remote_identity_healthcheck_username'),
6133            secret_store_id=d.get('secret_store_id'),
6134            tags=d.get('tags'),
6135        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6014    def __init__(
6015        self,
6016        bind_interface=None,
6017        certificate_authority=None,
6018        client_certificate=None,
6019        client_key=None,
6020        egress_filter=None,
6021        healthcheck_namespace=None,
6022        healthy=None,
6023        hostname=None,
6024        id=None,
6025        name=None,
6026        port=None,
6027        port_override=None,
6028        remote_identity_group_id=None,
6029        remote_identity_healthcheck_username=None,
6030        secret_store_id=None,
6031        tags=None,
6032    ):
6033        self.bind_interface = bind_interface if bind_interface is not None else ''
6034        '''
6035         Bind interface
6036        '''
6037        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6038        self.client_certificate = client_certificate if client_certificate is not None else ''
6039        self.client_key = client_key if client_key is not None else ''
6040        self.egress_filter = egress_filter if egress_filter is not None else ''
6041        '''
6042         A filter applied to the routing logic to pin datasource to nodes.
6043        '''
6044        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6045        '''
6046         The path used to check the health of your connection.  Defaults to `default`.
6047        '''
6048        self.healthy = healthy if healthy is not None else False
6049        '''
6050         True if the datasource is reachable and the credentials are valid.
6051        '''
6052        self.hostname = hostname if hostname is not None else ''
6053        self.id = id if id is not None else ''
6054        '''
6055         Unique identifier of the Resource.
6056        '''
6057        self.name = name if name is not None else ''
6058        '''
6059         Unique human-readable name of the Resource.
6060        '''
6061        self.port = port if port is not None else 0
6062        self.port_override = port_override if port_override is not None else 0
6063        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6064        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6065        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6066        '''
6067         ID of the secret store containing credentials for this resource, if any.
6068        '''
6069        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6070        '''
6071         Tags is a map of key, value pairs.
6072        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6094    def to_dict(self):
6095        return {
6096            'bind_interface': self.bind_interface,
6097            'certificate_authority': self.certificate_authority,
6098            'client_certificate': self.client_certificate,
6099            'client_key': self.client_key,
6100            'egress_filter': self.egress_filter,
6101            'healthcheck_namespace': self.healthcheck_namespace,
6102            'healthy': self.healthy,
6103            'hostname': self.hostname,
6104            'id': self.id,
6105            'name': self.name,
6106            'port': self.port,
6107            'port_override': self.port_override,
6108            'remote_identity_group_id': self.remote_identity_group_id,
6109            'remote_identity_healthcheck_username':
6110            self.remote_identity_healthcheck_username,
6111            'secret_store_id': self.secret_store_id,
6112            'tags': self.tags,
6113        }
@classmethod
def from_dict(cls, d)
6115    @classmethod
6116    def from_dict(cls, d):
6117        return cls(
6118            bind_interface=d.get('bind_interface'),
6119            certificate_authority=d.get('certificate_authority'),
6120            client_certificate=d.get('client_certificate'),
6121            client_key=d.get('client_key'),
6122            egress_filter=d.get('egress_filter'),
6123            healthcheck_namespace=d.get('healthcheck_namespace'),
6124            healthy=d.get('healthy'),
6125            hostname=d.get('hostname'),
6126            id=d.get('id'),
6127            name=d.get('name'),
6128            port=d.get('port'),
6129            port_override=d.get('port_override'),
6130            remote_identity_group_id=d.get('remote_identity_group_id'),
6131            remote_identity_healthcheck_username=d.get(
6132                'remote_identity_healthcheck_username'),
6133            secret_store_id=d.get('secret_store_id'),
6134            tags=d.get('tags'),
6135        )
class KubernetesBasicAuth:
6138class KubernetesBasicAuth:
6139    __slots__ = [
6140        'bind_interface',
6141        'egress_filter',
6142        'healthcheck_namespace',
6143        'healthy',
6144        'hostname',
6145        'id',
6146        'name',
6147        'password',
6148        'port',
6149        'port_override',
6150        'secret_store_id',
6151        'tags',
6152        'username',
6153    ]
6154
6155    def __init__(
6156        self,
6157        bind_interface=None,
6158        egress_filter=None,
6159        healthcheck_namespace=None,
6160        healthy=None,
6161        hostname=None,
6162        id=None,
6163        name=None,
6164        password=None,
6165        port=None,
6166        port_override=None,
6167        secret_store_id=None,
6168        tags=None,
6169        username=None,
6170    ):
6171        self.bind_interface = bind_interface if bind_interface is not None else ''
6172        '''
6173         Bind interface
6174        '''
6175        self.egress_filter = egress_filter if egress_filter is not None else ''
6176        '''
6177         A filter applied to the routing logic to pin datasource to nodes.
6178        '''
6179        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6180        '''
6181         The path used to check the health of your connection.  Defaults to `default`.
6182        '''
6183        self.healthy = healthy if healthy is not None else False
6184        '''
6185         True if the datasource is reachable and the credentials are valid.
6186        '''
6187        self.hostname = hostname if hostname is not None else ''
6188        self.id = id if id is not None else ''
6189        '''
6190         Unique identifier of the Resource.
6191        '''
6192        self.name = name if name is not None else ''
6193        '''
6194         Unique human-readable name of the Resource.
6195        '''
6196        self.password = password if password is not None else ''
6197        self.port = port if port is not None else 0
6198        self.port_override = port_override if port_override is not None else 0
6199        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6200        '''
6201         ID of the secret store containing credentials for this resource, if any.
6202        '''
6203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6204        '''
6205         Tags is a map of key, value pairs.
6206        '''
6207        self.username = username if username is not None else ''
6208
6209    def __repr__(self):
6210        return '<sdm.KubernetesBasicAuth ' + \
6211            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6212            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6213            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6214            'healthy: ' + repr(self.healthy) + ' ' +\
6215            'hostname: ' + repr(self.hostname) + ' ' +\
6216            'id: ' + repr(self.id) + ' ' +\
6217            'name: ' + repr(self.name) + ' ' +\
6218            'password: ' + repr(self.password) + ' ' +\
6219            'port: ' + repr(self.port) + ' ' +\
6220            'port_override: ' + repr(self.port_override) + ' ' +\
6221            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6222            'tags: ' + repr(self.tags) + ' ' +\
6223            'username: ' + repr(self.username) + ' ' +\
6224            '>'
6225
6226    def to_dict(self):
6227        return {
6228            'bind_interface': self.bind_interface,
6229            'egress_filter': self.egress_filter,
6230            'healthcheck_namespace': self.healthcheck_namespace,
6231            'healthy': self.healthy,
6232            'hostname': self.hostname,
6233            'id': self.id,
6234            'name': self.name,
6235            'password': self.password,
6236            'port': self.port,
6237            'port_override': self.port_override,
6238            'secret_store_id': self.secret_store_id,
6239            'tags': self.tags,
6240            'username': self.username,
6241        }
6242
6243    @classmethod
6244    def from_dict(cls, d):
6245        return cls(
6246            bind_interface=d.get('bind_interface'),
6247            egress_filter=d.get('egress_filter'),
6248            healthcheck_namespace=d.get('healthcheck_namespace'),
6249            healthy=d.get('healthy'),
6250            hostname=d.get('hostname'),
6251            id=d.get('id'),
6252            name=d.get('name'),
6253            password=d.get('password'),
6254            port=d.get('port'),
6255            port_override=d.get('port_override'),
6256            secret_store_id=d.get('secret_store_id'),
6257            tags=d.get('tags'),
6258            username=d.get('username'),
6259        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6155    def __init__(
6156        self,
6157        bind_interface=None,
6158        egress_filter=None,
6159        healthcheck_namespace=None,
6160        healthy=None,
6161        hostname=None,
6162        id=None,
6163        name=None,
6164        password=None,
6165        port=None,
6166        port_override=None,
6167        secret_store_id=None,
6168        tags=None,
6169        username=None,
6170    ):
6171        self.bind_interface = bind_interface if bind_interface is not None else ''
6172        '''
6173         Bind interface
6174        '''
6175        self.egress_filter = egress_filter if egress_filter is not None else ''
6176        '''
6177         A filter applied to the routing logic to pin datasource to nodes.
6178        '''
6179        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6180        '''
6181         The path used to check the health of your connection.  Defaults to `default`.
6182        '''
6183        self.healthy = healthy if healthy is not None else False
6184        '''
6185         True if the datasource is reachable and the credentials are valid.
6186        '''
6187        self.hostname = hostname if hostname is not None else ''
6188        self.id = id if id is not None else ''
6189        '''
6190         Unique identifier of the Resource.
6191        '''
6192        self.name = name if name is not None else ''
6193        '''
6194         Unique human-readable name of the Resource.
6195        '''
6196        self.password = password if password is not None else ''
6197        self.port = port if port is not None else 0
6198        self.port_override = port_override if port_override is not None else 0
6199        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6200        '''
6201         ID of the secret store containing credentials for this resource, if any.
6202        '''
6203        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6204        '''
6205         Tags is a map of key, value pairs.
6206        '''
6207        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6226    def to_dict(self):
6227        return {
6228            'bind_interface': self.bind_interface,
6229            'egress_filter': self.egress_filter,
6230            'healthcheck_namespace': self.healthcheck_namespace,
6231            'healthy': self.healthy,
6232            'hostname': self.hostname,
6233            'id': self.id,
6234            'name': self.name,
6235            'password': self.password,
6236            'port': self.port,
6237            'port_override': self.port_override,
6238            'secret_store_id': self.secret_store_id,
6239            'tags': self.tags,
6240            'username': self.username,
6241        }
@classmethod
def from_dict(cls, d)
6243    @classmethod
6244    def from_dict(cls, d):
6245        return cls(
6246            bind_interface=d.get('bind_interface'),
6247            egress_filter=d.get('egress_filter'),
6248            healthcheck_namespace=d.get('healthcheck_namespace'),
6249            healthy=d.get('healthy'),
6250            hostname=d.get('hostname'),
6251            id=d.get('id'),
6252            name=d.get('name'),
6253            password=d.get('password'),
6254            port=d.get('port'),
6255            port_override=d.get('port_override'),
6256            secret_store_id=d.get('secret_store_id'),
6257            tags=d.get('tags'),
6258            username=d.get('username'),
6259        )
class KubernetesServiceAccount:
6262class KubernetesServiceAccount:
6263    __slots__ = [
6264        'bind_interface',
6265        'egress_filter',
6266        'healthcheck_namespace',
6267        'healthy',
6268        'hostname',
6269        'id',
6270        'name',
6271        'port',
6272        'port_override',
6273        'remote_identity_group_id',
6274        'remote_identity_healthcheck_username',
6275        'secret_store_id',
6276        'tags',
6277        'token',
6278    ]
6279
6280    def __init__(
6281        self,
6282        bind_interface=None,
6283        egress_filter=None,
6284        healthcheck_namespace=None,
6285        healthy=None,
6286        hostname=None,
6287        id=None,
6288        name=None,
6289        port=None,
6290        port_override=None,
6291        remote_identity_group_id=None,
6292        remote_identity_healthcheck_username=None,
6293        secret_store_id=None,
6294        tags=None,
6295        token=None,
6296    ):
6297        self.bind_interface = bind_interface if bind_interface is not None else ''
6298        '''
6299         Bind interface
6300        '''
6301        self.egress_filter = egress_filter if egress_filter is not None else ''
6302        '''
6303         A filter applied to the routing logic to pin datasource to nodes.
6304        '''
6305        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6306        '''
6307         The path used to check the health of your connection.  Defaults to `default`.
6308        '''
6309        self.healthy = healthy if healthy is not None else False
6310        '''
6311         True if the datasource is reachable and the credentials are valid.
6312        '''
6313        self.hostname = hostname if hostname is not None else ''
6314        self.id = id if id is not None else ''
6315        '''
6316         Unique identifier of the Resource.
6317        '''
6318        self.name = name if name is not None else ''
6319        '''
6320         Unique human-readable name of the Resource.
6321        '''
6322        self.port = port if port is not None else 0
6323        self.port_override = port_override if port_override is not None else 0
6324        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6325        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6326        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6327        '''
6328         ID of the secret store containing credentials for this resource, if any.
6329        '''
6330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6331        '''
6332         Tags is a map of key, value pairs.
6333        '''
6334        self.token = token if token is not None else ''
6335
6336    def __repr__(self):
6337        return '<sdm.KubernetesServiceAccount ' + \
6338            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6339            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6340            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6341            'healthy: ' + repr(self.healthy) + ' ' +\
6342            'hostname: ' + repr(self.hostname) + ' ' +\
6343            'id: ' + repr(self.id) + ' ' +\
6344            'name: ' + repr(self.name) + ' ' +\
6345            'port: ' + repr(self.port) + ' ' +\
6346            'port_override: ' + repr(self.port_override) + ' ' +\
6347            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6348            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6349            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6350            'tags: ' + repr(self.tags) + ' ' +\
6351            'token: ' + repr(self.token) + ' ' +\
6352            '>'
6353
6354    def to_dict(self):
6355        return {
6356            'bind_interface': self.bind_interface,
6357            'egress_filter': self.egress_filter,
6358            'healthcheck_namespace': self.healthcheck_namespace,
6359            'healthy': self.healthy,
6360            'hostname': self.hostname,
6361            'id': self.id,
6362            'name': self.name,
6363            'port': self.port,
6364            'port_override': self.port_override,
6365            'remote_identity_group_id': self.remote_identity_group_id,
6366            'remote_identity_healthcheck_username':
6367            self.remote_identity_healthcheck_username,
6368            'secret_store_id': self.secret_store_id,
6369            'tags': self.tags,
6370            'token': self.token,
6371        }
6372
6373    @classmethod
6374    def from_dict(cls, d):
6375        return cls(
6376            bind_interface=d.get('bind_interface'),
6377            egress_filter=d.get('egress_filter'),
6378            healthcheck_namespace=d.get('healthcheck_namespace'),
6379            healthy=d.get('healthy'),
6380            hostname=d.get('hostname'),
6381            id=d.get('id'),
6382            name=d.get('name'),
6383            port=d.get('port'),
6384            port_override=d.get('port_override'),
6385            remote_identity_group_id=d.get('remote_identity_group_id'),
6386            remote_identity_healthcheck_username=d.get(
6387                'remote_identity_healthcheck_username'),
6388            secret_store_id=d.get('secret_store_id'),
6389            tags=d.get('tags'),
6390            token=d.get('token'),
6391        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6280    def __init__(
6281        self,
6282        bind_interface=None,
6283        egress_filter=None,
6284        healthcheck_namespace=None,
6285        healthy=None,
6286        hostname=None,
6287        id=None,
6288        name=None,
6289        port=None,
6290        port_override=None,
6291        remote_identity_group_id=None,
6292        remote_identity_healthcheck_username=None,
6293        secret_store_id=None,
6294        tags=None,
6295        token=None,
6296    ):
6297        self.bind_interface = bind_interface if bind_interface is not None else ''
6298        '''
6299         Bind interface
6300        '''
6301        self.egress_filter = egress_filter if egress_filter is not None else ''
6302        '''
6303         A filter applied to the routing logic to pin datasource to nodes.
6304        '''
6305        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6306        '''
6307         The path used to check the health of your connection.  Defaults to `default`.
6308        '''
6309        self.healthy = healthy if healthy is not None else False
6310        '''
6311         True if the datasource is reachable and the credentials are valid.
6312        '''
6313        self.hostname = hostname if hostname is not None else ''
6314        self.id = id if id is not None else ''
6315        '''
6316         Unique identifier of the Resource.
6317        '''
6318        self.name = name if name is not None else ''
6319        '''
6320         Unique human-readable name of the Resource.
6321        '''
6322        self.port = port if port is not None else 0
6323        self.port_override = port_override if port_override is not None else 0
6324        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6325        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6326        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6327        '''
6328         ID of the secret store containing credentials for this resource, if any.
6329        '''
6330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6331        '''
6332         Tags is a map of key, value pairs.
6333        '''
6334        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6354    def to_dict(self):
6355        return {
6356            'bind_interface': self.bind_interface,
6357            'egress_filter': self.egress_filter,
6358            'healthcheck_namespace': self.healthcheck_namespace,
6359            'healthy': self.healthy,
6360            'hostname': self.hostname,
6361            'id': self.id,
6362            'name': self.name,
6363            'port': self.port,
6364            'port_override': self.port_override,
6365            'remote_identity_group_id': self.remote_identity_group_id,
6366            'remote_identity_healthcheck_username':
6367            self.remote_identity_healthcheck_username,
6368            'secret_store_id': self.secret_store_id,
6369            'tags': self.tags,
6370            'token': self.token,
6371        }
@classmethod
def from_dict(cls, d)
6373    @classmethod
6374    def from_dict(cls, d):
6375        return cls(
6376            bind_interface=d.get('bind_interface'),
6377            egress_filter=d.get('egress_filter'),
6378            healthcheck_namespace=d.get('healthcheck_namespace'),
6379            healthy=d.get('healthy'),
6380            hostname=d.get('hostname'),
6381            id=d.get('id'),
6382            name=d.get('name'),
6383            port=d.get('port'),
6384            port_override=d.get('port_override'),
6385            remote_identity_group_id=d.get('remote_identity_group_id'),
6386            remote_identity_healthcheck_username=d.get(
6387                'remote_identity_healthcheck_username'),
6388            secret_store_id=d.get('secret_store_id'),
6389            tags=d.get('tags'),
6390            token=d.get('token'),
6391        )
class KubernetesServiceAccountUserImpersonation:
6394class KubernetesServiceAccountUserImpersonation:
6395    __slots__ = [
6396        'bind_interface',
6397        'egress_filter',
6398        'healthcheck_namespace',
6399        'healthy',
6400        'hostname',
6401        'id',
6402        'name',
6403        'port',
6404        'port_override',
6405        'secret_store_id',
6406        'tags',
6407        'token',
6408    ]
6409
6410    def __init__(
6411        self,
6412        bind_interface=None,
6413        egress_filter=None,
6414        healthcheck_namespace=None,
6415        healthy=None,
6416        hostname=None,
6417        id=None,
6418        name=None,
6419        port=None,
6420        port_override=None,
6421        secret_store_id=None,
6422        tags=None,
6423        token=None,
6424    ):
6425        self.bind_interface = bind_interface if bind_interface is not None else ''
6426        '''
6427         Bind interface
6428        '''
6429        self.egress_filter = egress_filter if egress_filter is not None else ''
6430        '''
6431         A filter applied to the routing logic to pin datasource to nodes.
6432        '''
6433        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6434        '''
6435         The path used to check the health of your connection.  Defaults to `default`.
6436        '''
6437        self.healthy = healthy if healthy is not None else False
6438        '''
6439         True if the datasource is reachable and the credentials are valid.
6440        '''
6441        self.hostname = hostname if hostname is not None else ''
6442        self.id = id if id is not None else ''
6443        '''
6444         Unique identifier of the Resource.
6445        '''
6446        self.name = name if name is not None else ''
6447        '''
6448         Unique human-readable name of the Resource.
6449        '''
6450        self.port = port if port is not None else 0
6451        self.port_override = port_override if port_override is not None else 0
6452        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6453        '''
6454         ID of the secret store containing credentials for this resource, if any.
6455        '''
6456        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6457        '''
6458         Tags is a map of key, value pairs.
6459        '''
6460        self.token = token if token is not None else ''
6461
6462    def __repr__(self):
6463        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6464            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6466            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6467            'healthy: ' + repr(self.healthy) + ' ' +\
6468            'hostname: ' + repr(self.hostname) + ' ' +\
6469            'id: ' + repr(self.id) + ' ' +\
6470            'name: ' + repr(self.name) + ' ' +\
6471            'port: ' + repr(self.port) + ' ' +\
6472            'port_override: ' + repr(self.port_override) + ' ' +\
6473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6474            'tags: ' + repr(self.tags) + ' ' +\
6475            'token: ' + repr(self.token) + ' ' +\
6476            '>'
6477
6478    def to_dict(self):
6479        return {
6480            'bind_interface': self.bind_interface,
6481            'egress_filter': self.egress_filter,
6482            'healthcheck_namespace': self.healthcheck_namespace,
6483            'healthy': self.healthy,
6484            'hostname': self.hostname,
6485            'id': self.id,
6486            'name': self.name,
6487            'port': self.port,
6488            'port_override': self.port_override,
6489            'secret_store_id': self.secret_store_id,
6490            'tags': self.tags,
6491            'token': self.token,
6492        }
6493
6494    @classmethod
6495    def from_dict(cls, d):
6496        return cls(
6497            bind_interface=d.get('bind_interface'),
6498            egress_filter=d.get('egress_filter'),
6499            healthcheck_namespace=d.get('healthcheck_namespace'),
6500            healthy=d.get('healthy'),
6501            hostname=d.get('hostname'),
6502            id=d.get('id'),
6503            name=d.get('name'),
6504            port=d.get('port'),
6505            port_override=d.get('port_override'),
6506            secret_store_id=d.get('secret_store_id'),
6507            tags=d.get('tags'),
6508            token=d.get('token'),
6509        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6410    def __init__(
6411        self,
6412        bind_interface=None,
6413        egress_filter=None,
6414        healthcheck_namespace=None,
6415        healthy=None,
6416        hostname=None,
6417        id=None,
6418        name=None,
6419        port=None,
6420        port_override=None,
6421        secret_store_id=None,
6422        tags=None,
6423        token=None,
6424    ):
6425        self.bind_interface = bind_interface if bind_interface is not None else ''
6426        '''
6427         Bind interface
6428        '''
6429        self.egress_filter = egress_filter if egress_filter is not None else ''
6430        '''
6431         A filter applied to the routing logic to pin datasource to nodes.
6432        '''
6433        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6434        '''
6435         The path used to check the health of your connection.  Defaults to `default`.
6436        '''
6437        self.healthy = healthy if healthy is not None else False
6438        '''
6439         True if the datasource is reachable and the credentials are valid.
6440        '''
6441        self.hostname = hostname if hostname is not None else ''
6442        self.id = id if id is not None else ''
6443        '''
6444         Unique identifier of the Resource.
6445        '''
6446        self.name = name if name is not None else ''
6447        '''
6448         Unique human-readable name of the Resource.
6449        '''
6450        self.port = port if port is not None else 0
6451        self.port_override = port_override if port_override is not None else 0
6452        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6453        '''
6454         ID of the secret store containing credentials for this resource, if any.
6455        '''
6456        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6457        '''
6458         Tags is a map of key, value pairs.
6459        '''
6460        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6478    def to_dict(self):
6479        return {
6480            'bind_interface': self.bind_interface,
6481            'egress_filter': self.egress_filter,
6482            'healthcheck_namespace': self.healthcheck_namespace,
6483            'healthy': self.healthy,
6484            'hostname': self.hostname,
6485            'id': self.id,
6486            'name': self.name,
6487            'port': self.port,
6488            'port_override': self.port_override,
6489            'secret_store_id': self.secret_store_id,
6490            'tags': self.tags,
6491            'token': self.token,
6492        }
@classmethod
def from_dict(cls, d)
6494    @classmethod
6495    def from_dict(cls, d):
6496        return cls(
6497            bind_interface=d.get('bind_interface'),
6498            egress_filter=d.get('egress_filter'),
6499            healthcheck_namespace=d.get('healthcheck_namespace'),
6500            healthy=d.get('healthy'),
6501            hostname=d.get('hostname'),
6502            id=d.get('id'),
6503            name=d.get('name'),
6504            port=d.get('port'),
6505            port_override=d.get('port_override'),
6506            secret_store_id=d.get('secret_store_id'),
6507            tags=d.get('tags'),
6508            token=d.get('token'),
6509        )
class KubernetesUserImpersonation:
6512class KubernetesUserImpersonation:
6513    __slots__ = [
6514        'bind_interface',
6515        'certificate_authority',
6516        'client_certificate',
6517        'client_key',
6518        'egress_filter',
6519        'healthcheck_namespace',
6520        'healthy',
6521        'hostname',
6522        'id',
6523        'name',
6524        'port',
6525        'port_override',
6526        'secret_store_id',
6527        'tags',
6528    ]
6529
6530    def __init__(
6531        self,
6532        bind_interface=None,
6533        certificate_authority=None,
6534        client_certificate=None,
6535        client_key=None,
6536        egress_filter=None,
6537        healthcheck_namespace=None,
6538        healthy=None,
6539        hostname=None,
6540        id=None,
6541        name=None,
6542        port=None,
6543        port_override=None,
6544        secret_store_id=None,
6545        tags=None,
6546    ):
6547        self.bind_interface = bind_interface if bind_interface is not None else ''
6548        '''
6549         Bind interface
6550        '''
6551        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6552        self.client_certificate = client_certificate if client_certificate is not None else ''
6553        self.client_key = client_key if client_key is not None else ''
6554        self.egress_filter = egress_filter if egress_filter is not None else ''
6555        '''
6556         A filter applied to the routing logic to pin datasource to nodes.
6557        '''
6558        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6559        '''
6560         The path used to check the health of your connection.  Defaults to `default`.
6561        '''
6562        self.healthy = healthy if healthy is not None else False
6563        '''
6564         True if the datasource is reachable and the credentials are valid.
6565        '''
6566        self.hostname = hostname if hostname is not None else ''
6567        self.id = id if id is not None else ''
6568        '''
6569         Unique identifier of the Resource.
6570        '''
6571        self.name = name if name is not None else ''
6572        '''
6573         Unique human-readable name of the Resource.
6574        '''
6575        self.port = port if port is not None else 0
6576        self.port_override = port_override if port_override is not None else 0
6577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6578        '''
6579         ID of the secret store containing credentials for this resource, if any.
6580        '''
6581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6582        '''
6583         Tags is a map of key, value pairs.
6584        '''
6585
6586    def __repr__(self):
6587        return '<sdm.KubernetesUserImpersonation ' + \
6588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6589            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6590            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6591            'client_key: ' + repr(self.client_key) + ' ' +\
6592            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6593            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6594            'healthy: ' + repr(self.healthy) + ' ' +\
6595            'hostname: ' + repr(self.hostname) + ' ' +\
6596            'id: ' + repr(self.id) + ' ' +\
6597            'name: ' + repr(self.name) + ' ' +\
6598            'port: ' + repr(self.port) + ' ' +\
6599            'port_override: ' + repr(self.port_override) + ' ' +\
6600            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6601            'tags: ' + repr(self.tags) + ' ' +\
6602            '>'
6603
6604    def to_dict(self):
6605        return {
6606            'bind_interface': self.bind_interface,
6607            'certificate_authority': self.certificate_authority,
6608            'client_certificate': self.client_certificate,
6609            'client_key': self.client_key,
6610            'egress_filter': self.egress_filter,
6611            'healthcheck_namespace': self.healthcheck_namespace,
6612            'healthy': self.healthy,
6613            'hostname': self.hostname,
6614            'id': self.id,
6615            'name': self.name,
6616            'port': self.port,
6617            'port_override': self.port_override,
6618            'secret_store_id': self.secret_store_id,
6619            'tags': self.tags,
6620        }
6621
6622    @classmethod
6623    def from_dict(cls, d):
6624        return cls(
6625            bind_interface=d.get('bind_interface'),
6626            certificate_authority=d.get('certificate_authority'),
6627            client_certificate=d.get('client_certificate'),
6628            client_key=d.get('client_key'),
6629            egress_filter=d.get('egress_filter'),
6630            healthcheck_namespace=d.get('healthcheck_namespace'),
6631            healthy=d.get('healthy'),
6632            hostname=d.get('hostname'),
6633            id=d.get('id'),
6634            name=d.get('name'),
6635            port=d.get('port'),
6636            port_override=d.get('port_override'),
6637            secret_store_id=d.get('secret_store_id'),
6638            tags=d.get('tags'),
6639        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6530    def __init__(
6531        self,
6532        bind_interface=None,
6533        certificate_authority=None,
6534        client_certificate=None,
6535        client_key=None,
6536        egress_filter=None,
6537        healthcheck_namespace=None,
6538        healthy=None,
6539        hostname=None,
6540        id=None,
6541        name=None,
6542        port=None,
6543        port_override=None,
6544        secret_store_id=None,
6545        tags=None,
6546    ):
6547        self.bind_interface = bind_interface if bind_interface is not None else ''
6548        '''
6549         Bind interface
6550        '''
6551        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6552        self.client_certificate = client_certificate if client_certificate is not None else ''
6553        self.client_key = client_key if client_key is not None else ''
6554        self.egress_filter = egress_filter if egress_filter is not None else ''
6555        '''
6556         A filter applied to the routing logic to pin datasource to nodes.
6557        '''
6558        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6559        '''
6560         The path used to check the health of your connection.  Defaults to `default`.
6561        '''
6562        self.healthy = healthy if healthy is not None else False
6563        '''
6564         True if the datasource is reachable and the credentials are valid.
6565        '''
6566        self.hostname = hostname if hostname is not None else ''
6567        self.id = id if id is not None else ''
6568        '''
6569         Unique identifier of the Resource.
6570        '''
6571        self.name = name if name is not None else ''
6572        '''
6573         Unique human-readable name of the Resource.
6574        '''
6575        self.port = port if port is not None else 0
6576        self.port_override = port_override if port_override is not None else 0
6577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6578        '''
6579         ID of the secret store containing credentials for this resource, if any.
6580        '''
6581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6582        '''
6583         Tags is a map of key, value pairs.
6584        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6604    def to_dict(self):
6605        return {
6606            'bind_interface': self.bind_interface,
6607            'certificate_authority': self.certificate_authority,
6608            'client_certificate': self.client_certificate,
6609            'client_key': self.client_key,
6610            'egress_filter': self.egress_filter,
6611            'healthcheck_namespace': self.healthcheck_namespace,
6612            'healthy': self.healthy,
6613            'hostname': self.hostname,
6614            'id': self.id,
6615            'name': self.name,
6616            'port': self.port,
6617            'port_override': self.port_override,
6618            'secret_store_id': self.secret_store_id,
6619            'tags': self.tags,
6620        }
@classmethod
def from_dict(cls, d)
6622    @classmethod
6623    def from_dict(cls, d):
6624        return cls(
6625            bind_interface=d.get('bind_interface'),
6626            certificate_authority=d.get('certificate_authority'),
6627            client_certificate=d.get('client_certificate'),
6628            client_key=d.get('client_key'),
6629            egress_filter=d.get('egress_filter'),
6630            healthcheck_namespace=d.get('healthcheck_namespace'),
6631            healthy=d.get('healthy'),
6632            hostname=d.get('hostname'),
6633            id=d.get('id'),
6634            name=d.get('name'),
6635            port=d.get('port'),
6636            port_override=d.get('port_override'),
6637            secret_store_id=d.get('secret_store_id'),
6638            tags=d.get('tags'),
6639        )
class MTLSMysql:
6642class MTLSMysql:
6643    '''
6644    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6645    without a major version bump.
6646    '''
6647    __slots__ = [
6648        'bind_interface',
6649        'certificate_authority',
6650        'client_certificate',
6651        'client_key',
6652        'database',
6653        'egress_filter',
6654        'healthy',
6655        'hostname',
6656        'id',
6657        'name',
6658        'password',
6659        'port',
6660        'port_override',
6661        'secret_store_id',
6662        'server_name',
6663        'tags',
6664        'username',
6665    ]
6666
6667    def __init__(
6668        self,
6669        bind_interface=None,
6670        certificate_authority=None,
6671        client_certificate=None,
6672        client_key=None,
6673        database=None,
6674        egress_filter=None,
6675        healthy=None,
6676        hostname=None,
6677        id=None,
6678        name=None,
6679        password=None,
6680        port=None,
6681        port_override=None,
6682        secret_store_id=None,
6683        server_name=None,
6684        tags=None,
6685        username=None,
6686    ):
6687        self.bind_interface = bind_interface if bind_interface is not None else ''
6688        '''
6689         Bind interface
6690        '''
6691        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6692        self.client_certificate = client_certificate if client_certificate is not None else ''
6693        self.client_key = client_key if client_key is not None else ''
6694        self.database = database if database is not None else ''
6695        self.egress_filter = egress_filter if egress_filter is not None else ''
6696        '''
6697         A filter applied to the routing logic to pin datasource to nodes.
6698        '''
6699        self.healthy = healthy if healthy is not None else False
6700        '''
6701         True if the datasource is reachable and the credentials are valid.
6702        '''
6703        self.hostname = hostname if hostname is not None else ''
6704        self.id = id if id is not None else ''
6705        '''
6706         Unique identifier of the Resource.
6707        '''
6708        self.name = name if name is not None else ''
6709        '''
6710         Unique human-readable name of the Resource.
6711        '''
6712        self.password = password if password is not None else ''
6713        self.port = port if port is not None else 0
6714        self.port_override = port_override if port_override is not None else 0
6715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6716        '''
6717         ID of the secret store containing credentials for this resource, if any.
6718        '''
6719        self.server_name = server_name if server_name is not None else ''
6720        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6721        '''
6722         Tags is a map of key, value pairs.
6723        '''
6724        self.username = username if username is not None else ''
6725
6726    def __repr__(self):
6727        return '<sdm.MTLSMysql ' + \
6728            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6729            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6730            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6731            'client_key: ' + repr(self.client_key) + ' ' +\
6732            'database: ' + repr(self.database) + ' ' +\
6733            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6734            'healthy: ' + repr(self.healthy) + ' ' +\
6735            'hostname: ' + repr(self.hostname) + ' ' +\
6736            'id: ' + repr(self.id) + ' ' +\
6737            'name: ' + repr(self.name) + ' ' +\
6738            'password: ' + repr(self.password) + ' ' +\
6739            'port: ' + repr(self.port) + ' ' +\
6740            'port_override: ' + repr(self.port_override) + ' ' +\
6741            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6742            'server_name: ' + repr(self.server_name) + ' ' +\
6743            'tags: ' + repr(self.tags) + ' ' +\
6744            'username: ' + repr(self.username) + ' ' +\
6745            '>'
6746
6747    def to_dict(self):
6748        return {
6749            'bind_interface': self.bind_interface,
6750            'certificate_authority': self.certificate_authority,
6751            'client_certificate': self.client_certificate,
6752            'client_key': self.client_key,
6753            'database': self.database,
6754            'egress_filter': self.egress_filter,
6755            'healthy': self.healthy,
6756            'hostname': self.hostname,
6757            'id': self.id,
6758            'name': self.name,
6759            'password': self.password,
6760            'port': self.port,
6761            'port_override': self.port_override,
6762            'secret_store_id': self.secret_store_id,
6763            'server_name': self.server_name,
6764            'tags': self.tags,
6765            'username': self.username,
6766        }
6767
6768    @classmethod
6769    def from_dict(cls, d):
6770        return cls(
6771            bind_interface=d.get('bind_interface'),
6772            certificate_authority=d.get('certificate_authority'),
6773            client_certificate=d.get('client_certificate'),
6774            client_key=d.get('client_key'),
6775            database=d.get('database'),
6776            egress_filter=d.get('egress_filter'),
6777            healthy=d.get('healthy'),
6778            hostname=d.get('hostname'),
6779            id=d.get('id'),
6780            name=d.get('name'),
6781            password=d.get('password'),
6782            port=d.get('port'),
6783            port_override=d.get('port_override'),
6784            secret_store_id=d.get('secret_store_id'),
6785            server_name=d.get('server_name'),
6786            tags=d.get('tags'),
6787            username=d.get('username'),
6788        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6667    def __init__(
6668        self,
6669        bind_interface=None,
6670        certificate_authority=None,
6671        client_certificate=None,
6672        client_key=None,
6673        database=None,
6674        egress_filter=None,
6675        healthy=None,
6676        hostname=None,
6677        id=None,
6678        name=None,
6679        password=None,
6680        port=None,
6681        port_override=None,
6682        secret_store_id=None,
6683        server_name=None,
6684        tags=None,
6685        username=None,
6686    ):
6687        self.bind_interface = bind_interface if bind_interface is not None else ''
6688        '''
6689         Bind interface
6690        '''
6691        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6692        self.client_certificate = client_certificate if client_certificate is not None else ''
6693        self.client_key = client_key if client_key is not None else ''
6694        self.database = database if database is not None else ''
6695        self.egress_filter = egress_filter if egress_filter is not None else ''
6696        '''
6697         A filter applied to the routing logic to pin datasource to nodes.
6698        '''
6699        self.healthy = healthy if healthy is not None else False
6700        '''
6701         True if the datasource is reachable and the credentials are valid.
6702        '''
6703        self.hostname = hostname if hostname is not None else ''
6704        self.id = id if id is not None else ''
6705        '''
6706         Unique identifier of the Resource.
6707        '''
6708        self.name = name if name is not None else ''
6709        '''
6710         Unique human-readable name of the Resource.
6711        '''
6712        self.password = password if password is not None else ''
6713        self.port = port if port is not None else 0
6714        self.port_override = port_override if port_override is not None else 0
6715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6716        '''
6717         ID of the secret store containing credentials for this resource, if any.
6718        '''
6719        self.server_name = server_name if server_name is not None else ''
6720        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6721        '''
6722         Tags is a map of key, value pairs.
6723        '''
6724        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6747    def to_dict(self):
6748        return {
6749            'bind_interface': self.bind_interface,
6750            'certificate_authority': self.certificate_authority,
6751            'client_certificate': self.client_certificate,
6752            'client_key': self.client_key,
6753            'database': self.database,
6754            'egress_filter': self.egress_filter,
6755            'healthy': self.healthy,
6756            'hostname': self.hostname,
6757            'id': self.id,
6758            'name': self.name,
6759            'password': self.password,
6760            'port': self.port,
6761            'port_override': self.port_override,
6762            'secret_store_id': self.secret_store_id,
6763            'server_name': self.server_name,
6764            'tags': self.tags,
6765            'username': self.username,
6766        }
@classmethod
def from_dict(cls, d)
6768    @classmethod
6769    def from_dict(cls, d):
6770        return cls(
6771            bind_interface=d.get('bind_interface'),
6772            certificate_authority=d.get('certificate_authority'),
6773            client_certificate=d.get('client_certificate'),
6774            client_key=d.get('client_key'),
6775            database=d.get('database'),
6776            egress_filter=d.get('egress_filter'),
6777            healthy=d.get('healthy'),
6778            hostname=d.get('hostname'),
6779            id=d.get('id'),
6780            name=d.get('name'),
6781            password=d.get('password'),
6782            port=d.get('port'),
6783            port_override=d.get('port_override'),
6784            secret_store_id=d.get('secret_store_id'),
6785            server_name=d.get('server_name'),
6786            tags=d.get('tags'),
6787            username=d.get('username'),
6788        )
class MTLSPostgres:
6791class MTLSPostgres:
6792    __slots__ = [
6793        'bind_interface',
6794        'certificate_authority',
6795        'client_certificate',
6796        'client_key',
6797        'database',
6798        'egress_filter',
6799        'healthy',
6800        'hostname',
6801        'id',
6802        'name',
6803        'override_database',
6804        'password',
6805        'port',
6806        'port_override',
6807        'secret_store_id',
6808        'server_name',
6809        'tags',
6810        'username',
6811    ]
6812
6813    def __init__(
6814        self,
6815        bind_interface=None,
6816        certificate_authority=None,
6817        client_certificate=None,
6818        client_key=None,
6819        database=None,
6820        egress_filter=None,
6821        healthy=None,
6822        hostname=None,
6823        id=None,
6824        name=None,
6825        override_database=None,
6826        password=None,
6827        port=None,
6828        port_override=None,
6829        secret_store_id=None,
6830        server_name=None,
6831        tags=None,
6832        username=None,
6833    ):
6834        self.bind_interface = bind_interface if bind_interface is not None else ''
6835        '''
6836         Bind interface
6837        '''
6838        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6839        self.client_certificate = client_certificate if client_certificate is not None else ''
6840        self.client_key = client_key if client_key is not None else ''
6841        self.database = database if database is not None else ''
6842        self.egress_filter = egress_filter if egress_filter is not None else ''
6843        '''
6844         A filter applied to the routing logic to pin datasource to nodes.
6845        '''
6846        self.healthy = healthy if healthy is not None else False
6847        '''
6848         True if the datasource is reachable and the credentials are valid.
6849        '''
6850        self.hostname = hostname if hostname is not None else ''
6851        self.id = id if id is not None else ''
6852        '''
6853         Unique identifier of the Resource.
6854        '''
6855        self.name = name if name is not None else ''
6856        '''
6857         Unique human-readable name of the Resource.
6858        '''
6859        self.override_database = override_database if override_database is not None else False
6860        self.password = password if password is not None else ''
6861        self.port = port if port is not None else 0
6862        self.port_override = port_override if port_override is not None else 0
6863        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6864        '''
6865         ID of the secret store containing credentials for this resource, if any.
6866        '''
6867        self.server_name = server_name if server_name is not None else ''
6868        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6869        '''
6870         Tags is a map of key, value pairs.
6871        '''
6872        self.username = username if username is not None else ''
6873
6874    def __repr__(self):
6875        return '<sdm.MTLSPostgres ' + \
6876            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6877            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6878            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6879            'client_key: ' + repr(self.client_key) + ' ' +\
6880            'database: ' + repr(self.database) + ' ' +\
6881            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6882            'healthy: ' + repr(self.healthy) + ' ' +\
6883            'hostname: ' + repr(self.hostname) + ' ' +\
6884            'id: ' + repr(self.id) + ' ' +\
6885            'name: ' + repr(self.name) + ' ' +\
6886            'override_database: ' + repr(self.override_database) + ' ' +\
6887            'password: ' + repr(self.password) + ' ' +\
6888            'port: ' + repr(self.port) + ' ' +\
6889            'port_override: ' + repr(self.port_override) + ' ' +\
6890            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6891            'server_name: ' + repr(self.server_name) + ' ' +\
6892            'tags: ' + repr(self.tags) + ' ' +\
6893            'username: ' + repr(self.username) + ' ' +\
6894            '>'
6895
6896    def to_dict(self):
6897        return {
6898            'bind_interface': self.bind_interface,
6899            'certificate_authority': self.certificate_authority,
6900            'client_certificate': self.client_certificate,
6901            'client_key': self.client_key,
6902            'database': self.database,
6903            'egress_filter': self.egress_filter,
6904            'healthy': self.healthy,
6905            'hostname': self.hostname,
6906            'id': self.id,
6907            'name': self.name,
6908            'override_database': self.override_database,
6909            'password': self.password,
6910            'port': self.port,
6911            'port_override': self.port_override,
6912            'secret_store_id': self.secret_store_id,
6913            'server_name': self.server_name,
6914            'tags': self.tags,
6915            'username': self.username,
6916        }
6917
6918    @classmethod
6919    def from_dict(cls, d):
6920        return cls(
6921            bind_interface=d.get('bind_interface'),
6922            certificate_authority=d.get('certificate_authority'),
6923            client_certificate=d.get('client_certificate'),
6924            client_key=d.get('client_key'),
6925            database=d.get('database'),
6926            egress_filter=d.get('egress_filter'),
6927            healthy=d.get('healthy'),
6928            hostname=d.get('hostname'),
6929            id=d.get('id'),
6930            name=d.get('name'),
6931            override_database=d.get('override_database'),
6932            password=d.get('password'),
6933            port=d.get('port'),
6934            port_override=d.get('port_override'),
6935            secret_store_id=d.get('secret_store_id'),
6936            server_name=d.get('server_name'),
6937            tags=d.get('tags'),
6938            username=d.get('username'),
6939        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6813    def __init__(
6814        self,
6815        bind_interface=None,
6816        certificate_authority=None,
6817        client_certificate=None,
6818        client_key=None,
6819        database=None,
6820        egress_filter=None,
6821        healthy=None,
6822        hostname=None,
6823        id=None,
6824        name=None,
6825        override_database=None,
6826        password=None,
6827        port=None,
6828        port_override=None,
6829        secret_store_id=None,
6830        server_name=None,
6831        tags=None,
6832        username=None,
6833    ):
6834        self.bind_interface = bind_interface if bind_interface is not None else ''
6835        '''
6836         Bind interface
6837        '''
6838        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6839        self.client_certificate = client_certificate if client_certificate is not None else ''
6840        self.client_key = client_key if client_key is not None else ''
6841        self.database = database if database is not None else ''
6842        self.egress_filter = egress_filter if egress_filter is not None else ''
6843        '''
6844         A filter applied to the routing logic to pin datasource to nodes.
6845        '''
6846        self.healthy = healthy if healthy is not None else False
6847        '''
6848         True if the datasource is reachable and the credentials are valid.
6849        '''
6850        self.hostname = hostname if hostname is not None else ''
6851        self.id = id if id is not None else ''
6852        '''
6853         Unique identifier of the Resource.
6854        '''
6855        self.name = name if name is not None else ''
6856        '''
6857         Unique human-readable name of the Resource.
6858        '''
6859        self.override_database = override_database if override_database is not None else False
6860        self.password = password if password is not None else ''
6861        self.port = port if port is not None else 0
6862        self.port_override = port_override if port_override is not None else 0
6863        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6864        '''
6865         ID of the secret store containing credentials for this resource, if any.
6866        '''
6867        self.server_name = server_name if server_name is not None else ''
6868        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6869        '''
6870         Tags is a map of key, value pairs.
6871        '''
6872        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6896    def to_dict(self):
6897        return {
6898            'bind_interface': self.bind_interface,
6899            'certificate_authority': self.certificate_authority,
6900            'client_certificate': self.client_certificate,
6901            'client_key': self.client_key,
6902            'database': self.database,
6903            'egress_filter': self.egress_filter,
6904            'healthy': self.healthy,
6905            'hostname': self.hostname,
6906            'id': self.id,
6907            'name': self.name,
6908            'override_database': self.override_database,
6909            'password': self.password,
6910            'port': self.port,
6911            'port_override': self.port_override,
6912            'secret_store_id': self.secret_store_id,
6913            'server_name': self.server_name,
6914            'tags': self.tags,
6915            'username': self.username,
6916        }
@classmethod
def from_dict(cls, d)
6918    @classmethod
6919    def from_dict(cls, d):
6920        return cls(
6921            bind_interface=d.get('bind_interface'),
6922            certificate_authority=d.get('certificate_authority'),
6923            client_certificate=d.get('client_certificate'),
6924            client_key=d.get('client_key'),
6925            database=d.get('database'),
6926            egress_filter=d.get('egress_filter'),
6927            healthy=d.get('healthy'),
6928            hostname=d.get('hostname'),
6929            id=d.get('id'),
6930            name=d.get('name'),
6931            override_database=d.get('override_database'),
6932            password=d.get('password'),
6933            port=d.get('port'),
6934            port_override=d.get('port_override'),
6935            secret_store_id=d.get('secret_store_id'),
6936            server_name=d.get('server_name'),
6937            tags=d.get('tags'),
6938            username=d.get('username'),
6939        )
class Maria:
6942class Maria:
6943    __slots__ = [
6944        'bind_interface',
6945        'database',
6946        'egress_filter',
6947        'healthy',
6948        'hostname',
6949        'id',
6950        'name',
6951        'password',
6952        'port',
6953        'port_override',
6954        'secret_store_id',
6955        'tags',
6956        'username',
6957    ]
6958
6959    def __init__(
6960        self,
6961        bind_interface=None,
6962        database=None,
6963        egress_filter=None,
6964        healthy=None,
6965        hostname=None,
6966        id=None,
6967        name=None,
6968        password=None,
6969        port=None,
6970        port_override=None,
6971        secret_store_id=None,
6972        tags=None,
6973        username=None,
6974    ):
6975        self.bind_interface = bind_interface if bind_interface is not None else ''
6976        '''
6977         Bind interface
6978        '''
6979        self.database = database if database is not None else ''
6980        self.egress_filter = egress_filter if egress_filter is not None else ''
6981        '''
6982         A filter applied to the routing logic to pin datasource to nodes.
6983        '''
6984        self.healthy = healthy if healthy is not None else False
6985        '''
6986         True if the datasource is reachable and the credentials are valid.
6987        '''
6988        self.hostname = hostname if hostname is not None else ''
6989        self.id = id if id is not None else ''
6990        '''
6991         Unique identifier of the Resource.
6992        '''
6993        self.name = name if name is not None else ''
6994        '''
6995         Unique human-readable name of the Resource.
6996        '''
6997        self.password = password if password is not None else ''
6998        self.port = port if port is not None else 0
6999        self.port_override = port_override if port_override is not None else 0
7000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7001        '''
7002         ID of the secret store containing credentials for this resource, if any.
7003        '''
7004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7005        '''
7006         Tags is a map of key, value pairs.
7007        '''
7008        self.username = username if username is not None else ''
7009
7010    def __repr__(self):
7011        return '<sdm.Maria ' + \
7012            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7013            'database: ' + repr(self.database) + ' ' +\
7014            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7015            'healthy: ' + repr(self.healthy) + ' ' +\
7016            'hostname: ' + repr(self.hostname) + ' ' +\
7017            'id: ' + repr(self.id) + ' ' +\
7018            'name: ' + repr(self.name) + ' ' +\
7019            'password: ' + repr(self.password) + ' ' +\
7020            'port: ' + repr(self.port) + ' ' +\
7021            'port_override: ' + repr(self.port_override) + ' ' +\
7022            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7023            'tags: ' + repr(self.tags) + ' ' +\
7024            'username: ' + repr(self.username) + ' ' +\
7025            '>'
7026
7027    def to_dict(self):
7028        return {
7029            'bind_interface': self.bind_interface,
7030            'database': self.database,
7031            'egress_filter': self.egress_filter,
7032            'healthy': self.healthy,
7033            'hostname': self.hostname,
7034            'id': self.id,
7035            'name': self.name,
7036            'password': self.password,
7037            'port': self.port,
7038            'port_override': self.port_override,
7039            'secret_store_id': self.secret_store_id,
7040            'tags': self.tags,
7041            'username': self.username,
7042        }
7043
7044    @classmethod
7045    def from_dict(cls, d):
7046        return cls(
7047            bind_interface=d.get('bind_interface'),
7048            database=d.get('database'),
7049            egress_filter=d.get('egress_filter'),
7050            healthy=d.get('healthy'),
7051            hostname=d.get('hostname'),
7052            id=d.get('id'),
7053            name=d.get('name'),
7054            password=d.get('password'),
7055            port=d.get('port'),
7056            port_override=d.get('port_override'),
7057            secret_store_id=d.get('secret_store_id'),
7058            tags=d.get('tags'),
7059            username=d.get('username'),
7060        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6959    def __init__(
6960        self,
6961        bind_interface=None,
6962        database=None,
6963        egress_filter=None,
6964        healthy=None,
6965        hostname=None,
6966        id=None,
6967        name=None,
6968        password=None,
6969        port=None,
6970        port_override=None,
6971        secret_store_id=None,
6972        tags=None,
6973        username=None,
6974    ):
6975        self.bind_interface = bind_interface if bind_interface is not None else ''
6976        '''
6977         Bind interface
6978        '''
6979        self.database = database if database is not None else ''
6980        self.egress_filter = egress_filter if egress_filter is not None else ''
6981        '''
6982         A filter applied to the routing logic to pin datasource to nodes.
6983        '''
6984        self.healthy = healthy if healthy is not None else False
6985        '''
6986         True if the datasource is reachable and the credentials are valid.
6987        '''
6988        self.hostname = hostname if hostname is not None else ''
6989        self.id = id if id is not None else ''
6990        '''
6991         Unique identifier of the Resource.
6992        '''
6993        self.name = name if name is not None else ''
6994        '''
6995         Unique human-readable name of the Resource.
6996        '''
6997        self.password = password if password is not None else ''
6998        self.port = port if port is not None else 0
6999        self.port_override = port_override if port_override is not None else 0
7000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7001        '''
7002         ID of the secret store containing credentials for this resource, if any.
7003        '''
7004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7005        '''
7006         Tags is a map of key, value pairs.
7007        '''
7008        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7027    def to_dict(self):
7028        return {
7029            'bind_interface': self.bind_interface,
7030            'database': self.database,
7031            'egress_filter': self.egress_filter,
7032            'healthy': self.healthy,
7033            'hostname': self.hostname,
7034            'id': self.id,
7035            'name': self.name,
7036            'password': self.password,
7037            'port': self.port,
7038            'port_override': self.port_override,
7039            'secret_store_id': self.secret_store_id,
7040            'tags': self.tags,
7041            'username': self.username,
7042        }
@classmethod
def from_dict(cls, d)
7044    @classmethod
7045    def from_dict(cls, d):
7046        return cls(
7047            bind_interface=d.get('bind_interface'),
7048            database=d.get('database'),
7049            egress_filter=d.get('egress_filter'),
7050            healthy=d.get('healthy'),
7051            hostname=d.get('hostname'),
7052            id=d.get('id'),
7053            name=d.get('name'),
7054            password=d.get('password'),
7055            port=d.get('port'),
7056            port_override=d.get('port_override'),
7057            secret_store_id=d.get('secret_store_id'),
7058            tags=d.get('tags'),
7059            username=d.get('username'),
7060        )
class Memcached:
7063class Memcached:
7064    __slots__ = [
7065        'bind_interface',
7066        'egress_filter',
7067        'healthy',
7068        'hostname',
7069        'id',
7070        'name',
7071        'port',
7072        'port_override',
7073        'secret_store_id',
7074        'tags',
7075    ]
7076
7077    def __init__(
7078        self,
7079        bind_interface=None,
7080        egress_filter=None,
7081        healthy=None,
7082        hostname=None,
7083        id=None,
7084        name=None,
7085        port=None,
7086        port_override=None,
7087        secret_store_id=None,
7088        tags=None,
7089    ):
7090        self.bind_interface = bind_interface if bind_interface is not None else ''
7091        '''
7092         Bind interface
7093        '''
7094        self.egress_filter = egress_filter if egress_filter is not None else ''
7095        '''
7096         A filter applied to the routing logic to pin datasource to nodes.
7097        '''
7098        self.healthy = healthy if healthy is not None else False
7099        '''
7100         True if the datasource is reachable and the credentials are valid.
7101        '''
7102        self.hostname = hostname if hostname is not None else ''
7103        self.id = id if id is not None else ''
7104        '''
7105         Unique identifier of the Resource.
7106        '''
7107        self.name = name if name is not None else ''
7108        '''
7109         Unique human-readable name of the Resource.
7110        '''
7111        self.port = port if port is not None else 0
7112        self.port_override = port_override if port_override is not None else 0
7113        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7114        '''
7115         ID of the secret store containing credentials for this resource, if any.
7116        '''
7117        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7118        '''
7119         Tags is a map of key, value pairs.
7120        '''
7121
7122    def __repr__(self):
7123        return '<sdm.Memcached ' + \
7124            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7125            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7126            'healthy: ' + repr(self.healthy) + ' ' +\
7127            'hostname: ' + repr(self.hostname) + ' ' +\
7128            'id: ' + repr(self.id) + ' ' +\
7129            'name: ' + repr(self.name) + ' ' +\
7130            'port: ' + repr(self.port) + ' ' +\
7131            'port_override: ' + repr(self.port_override) + ' ' +\
7132            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7133            'tags: ' + repr(self.tags) + ' ' +\
7134            '>'
7135
7136    def to_dict(self):
7137        return {
7138            'bind_interface': self.bind_interface,
7139            'egress_filter': self.egress_filter,
7140            'healthy': self.healthy,
7141            'hostname': self.hostname,
7142            'id': self.id,
7143            'name': self.name,
7144            'port': self.port,
7145            'port_override': self.port_override,
7146            'secret_store_id': self.secret_store_id,
7147            'tags': self.tags,
7148        }
7149
7150    @classmethod
7151    def from_dict(cls, d):
7152        return cls(
7153            bind_interface=d.get('bind_interface'),
7154            egress_filter=d.get('egress_filter'),
7155            healthy=d.get('healthy'),
7156            hostname=d.get('hostname'),
7157            id=d.get('id'),
7158            name=d.get('name'),
7159            port=d.get('port'),
7160            port_override=d.get('port_override'),
7161            secret_store_id=d.get('secret_store_id'),
7162            tags=d.get('tags'),
7163        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7077    def __init__(
7078        self,
7079        bind_interface=None,
7080        egress_filter=None,
7081        healthy=None,
7082        hostname=None,
7083        id=None,
7084        name=None,
7085        port=None,
7086        port_override=None,
7087        secret_store_id=None,
7088        tags=None,
7089    ):
7090        self.bind_interface = bind_interface if bind_interface is not None else ''
7091        '''
7092         Bind interface
7093        '''
7094        self.egress_filter = egress_filter if egress_filter is not None else ''
7095        '''
7096         A filter applied to the routing logic to pin datasource to nodes.
7097        '''
7098        self.healthy = healthy if healthy is not None else False
7099        '''
7100         True if the datasource is reachable and the credentials are valid.
7101        '''
7102        self.hostname = hostname if hostname is not None else ''
7103        self.id = id if id is not None else ''
7104        '''
7105         Unique identifier of the Resource.
7106        '''
7107        self.name = name if name is not None else ''
7108        '''
7109         Unique human-readable name of the Resource.
7110        '''
7111        self.port = port if port is not None else 0
7112        self.port_override = port_override if port_override is not None else 0
7113        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7114        '''
7115         ID of the secret store containing credentials for this resource, if any.
7116        '''
7117        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7118        '''
7119         Tags is a map of key, value pairs.
7120        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7136    def to_dict(self):
7137        return {
7138            'bind_interface': self.bind_interface,
7139            'egress_filter': self.egress_filter,
7140            'healthy': self.healthy,
7141            'hostname': self.hostname,
7142            'id': self.id,
7143            'name': self.name,
7144            'port': self.port,
7145            'port_override': self.port_override,
7146            'secret_store_id': self.secret_store_id,
7147            'tags': self.tags,
7148        }
@classmethod
def from_dict(cls, d)
7150    @classmethod
7151    def from_dict(cls, d):
7152        return cls(
7153            bind_interface=d.get('bind_interface'),
7154            egress_filter=d.get('egress_filter'),
7155            healthy=d.get('healthy'),
7156            hostname=d.get('hostname'),
7157            id=d.get('id'),
7158            name=d.get('name'),
7159            port=d.get('port'),
7160            port_override=d.get('port_override'),
7161            secret_store_id=d.get('secret_store_id'),
7162            tags=d.get('tags'),
7163        )
class Memsql:
7166class Memsql:
7167    __slots__ = [
7168        'bind_interface',
7169        'database',
7170        'egress_filter',
7171        'healthy',
7172        'hostname',
7173        'id',
7174        'name',
7175        'password',
7176        'port',
7177        'port_override',
7178        'secret_store_id',
7179        'tags',
7180        'username',
7181    ]
7182
7183    def __init__(
7184        self,
7185        bind_interface=None,
7186        database=None,
7187        egress_filter=None,
7188        healthy=None,
7189        hostname=None,
7190        id=None,
7191        name=None,
7192        password=None,
7193        port=None,
7194        port_override=None,
7195        secret_store_id=None,
7196        tags=None,
7197        username=None,
7198    ):
7199        self.bind_interface = bind_interface if bind_interface is not None else ''
7200        '''
7201         Bind interface
7202        '''
7203        self.database = database if database is not None else ''
7204        self.egress_filter = egress_filter if egress_filter is not None else ''
7205        '''
7206         A filter applied to the routing logic to pin datasource to nodes.
7207        '''
7208        self.healthy = healthy if healthy is not None else False
7209        '''
7210         True if the datasource is reachable and the credentials are valid.
7211        '''
7212        self.hostname = hostname if hostname is not None else ''
7213        self.id = id if id is not None else ''
7214        '''
7215         Unique identifier of the Resource.
7216        '''
7217        self.name = name if name is not None else ''
7218        '''
7219         Unique human-readable name of the Resource.
7220        '''
7221        self.password = password if password is not None else ''
7222        self.port = port if port is not None else 0
7223        self.port_override = port_override if port_override is not None else 0
7224        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7225        '''
7226         ID of the secret store containing credentials for this resource, if any.
7227        '''
7228        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7229        '''
7230         Tags is a map of key, value pairs.
7231        '''
7232        self.username = username if username is not None else ''
7233
7234    def __repr__(self):
7235        return '<sdm.Memsql ' + \
7236            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7237            'database: ' + repr(self.database) + ' ' +\
7238            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7239            'healthy: ' + repr(self.healthy) + ' ' +\
7240            'hostname: ' + repr(self.hostname) + ' ' +\
7241            'id: ' + repr(self.id) + ' ' +\
7242            'name: ' + repr(self.name) + ' ' +\
7243            'password: ' + repr(self.password) + ' ' +\
7244            'port: ' + repr(self.port) + ' ' +\
7245            'port_override: ' + repr(self.port_override) + ' ' +\
7246            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7247            'tags: ' + repr(self.tags) + ' ' +\
7248            'username: ' + repr(self.username) + ' ' +\
7249            '>'
7250
7251    def to_dict(self):
7252        return {
7253            'bind_interface': self.bind_interface,
7254            'database': self.database,
7255            'egress_filter': self.egress_filter,
7256            'healthy': self.healthy,
7257            'hostname': self.hostname,
7258            'id': self.id,
7259            'name': self.name,
7260            'password': self.password,
7261            'port': self.port,
7262            'port_override': self.port_override,
7263            'secret_store_id': self.secret_store_id,
7264            'tags': self.tags,
7265            'username': self.username,
7266        }
7267
7268    @classmethod
7269    def from_dict(cls, d):
7270        return cls(
7271            bind_interface=d.get('bind_interface'),
7272            database=d.get('database'),
7273            egress_filter=d.get('egress_filter'),
7274            healthy=d.get('healthy'),
7275            hostname=d.get('hostname'),
7276            id=d.get('id'),
7277            name=d.get('name'),
7278            password=d.get('password'),
7279            port=d.get('port'),
7280            port_override=d.get('port_override'),
7281            secret_store_id=d.get('secret_store_id'),
7282            tags=d.get('tags'),
7283            username=d.get('username'),
7284        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7183    def __init__(
7184        self,
7185        bind_interface=None,
7186        database=None,
7187        egress_filter=None,
7188        healthy=None,
7189        hostname=None,
7190        id=None,
7191        name=None,
7192        password=None,
7193        port=None,
7194        port_override=None,
7195        secret_store_id=None,
7196        tags=None,
7197        username=None,
7198    ):
7199        self.bind_interface = bind_interface if bind_interface is not None else ''
7200        '''
7201         Bind interface
7202        '''
7203        self.database = database if database is not None else ''
7204        self.egress_filter = egress_filter if egress_filter is not None else ''
7205        '''
7206         A filter applied to the routing logic to pin datasource to nodes.
7207        '''
7208        self.healthy = healthy if healthy is not None else False
7209        '''
7210         True if the datasource is reachable and the credentials are valid.
7211        '''
7212        self.hostname = hostname if hostname is not None else ''
7213        self.id = id if id is not None else ''
7214        '''
7215         Unique identifier of the Resource.
7216        '''
7217        self.name = name if name is not None else ''
7218        '''
7219         Unique human-readable name of the Resource.
7220        '''
7221        self.password = password if password is not None else ''
7222        self.port = port if port is not None else 0
7223        self.port_override = port_override if port_override is not None else 0
7224        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7225        '''
7226         ID of the secret store containing credentials for this resource, if any.
7227        '''
7228        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7229        '''
7230         Tags is a map of key, value pairs.
7231        '''
7232        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7251    def to_dict(self):
7252        return {
7253            'bind_interface': self.bind_interface,
7254            'database': self.database,
7255            'egress_filter': self.egress_filter,
7256            'healthy': self.healthy,
7257            'hostname': self.hostname,
7258            'id': self.id,
7259            'name': self.name,
7260            'password': self.password,
7261            'port': self.port,
7262            'port_override': self.port_override,
7263            'secret_store_id': self.secret_store_id,
7264            'tags': self.tags,
7265            'username': self.username,
7266        }
@classmethod
def from_dict(cls, d)
7268    @classmethod
7269    def from_dict(cls, d):
7270        return cls(
7271            bind_interface=d.get('bind_interface'),
7272            database=d.get('database'),
7273            egress_filter=d.get('egress_filter'),
7274            healthy=d.get('healthy'),
7275            hostname=d.get('hostname'),
7276            id=d.get('id'),
7277            name=d.get('name'),
7278            password=d.get('password'),
7279            port=d.get('port'),
7280            port_override=d.get('port_override'),
7281            secret_store_id=d.get('secret_store_id'),
7282            tags=d.get('tags'),
7283            username=d.get('username'),
7284        )
class MongoHost:
7287class MongoHost:
7288    '''
7289    MongoHost is currently unstable, and its API may change, or it may be removed,
7290    without a major version bump.
7291    '''
7292    __slots__ = [
7293        'auth_database',
7294        'bind_interface',
7295        'egress_filter',
7296        'healthy',
7297        'hostname',
7298        'id',
7299        'name',
7300        'password',
7301        'port',
7302        'port_override',
7303        'secret_store_id',
7304        'tags',
7305        'tls_required',
7306        'username',
7307    ]
7308
7309    def __init__(
7310        self,
7311        auth_database=None,
7312        bind_interface=None,
7313        egress_filter=None,
7314        healthy=None,
7315        hostname=None,
7316        id=None,
7317        name=None,
7318        password=None,
7319        port=None,
7320        port_override=None,
7321        secret_store_id=None,
7322        tags=None,
7323        tls_required=None,
7324        username=None,
7325    ):
7326        self.auth_database = auth_database if auth_database is not None else ''
7327        self.bind_interface = bind_interface if bind_interface is not None else ''
7328        '''
7329         Bind interface
7330        '''
7331        self.egress_filter = egress_filter if egress_filter is not None else ''
7332        '''
7333         A filter applied to the routing logic to pin datasource to nodes.
7334        '''
7335        self.healthy = healthy if healthy is not None else False
7336        '''
7337         True if the datasource is reachable and the credentials are valid.
7338        '''
7339        self.hostname = hostname if hostname is not None else ''
7340        self.id = id if id is not None else ''
7341        '''
7342         Unique identifier of the Resource.
7343        '''
7344        self.name = name if name is not None else ''
7345        '''
7346         Unique human-readable name of the Resource.
7347        '''
7348        self.password = password if password is not None else ''
7349        self.port = port if port is not None else 0
7350        self.port_override = port_override if port_override is not None else 0
7351        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7352        '''
7353         ID of the secret store containing credentials for this resource, if any.
7354        '''
7355        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7356        '''
7357         Tags is a map of key, value pairs.
7358        '''
7359        self.tls_required = tls_required if tls_required is not None else False
7360        self.username = username if username is not None else ''
7361
7362    def __repr__(self):
7363        return '<sdm.MongoHost ' + \
7364            'auth_database: ' + repr(self.auth_database) + ' ' +\
7365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7367            'healthy: ' + repr(self.healthy) + ' ' +\
7368            'hostname: ' + repr(self.hostname) + ' ' +\
7369            'id: ' + repr(self.id) + ' ' +\
7370            'name: ' + repr(self.name) + ' ' +\
7371            'password: ' + repr(self.password) + ' ' +\
7372            'port: ' + repr(self.port) + ' ' +\
7373            'port_override: ' + repr(self.port_override) + ' ' +\
7374            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7375            'tags: ' + repr(self.tags) + ' ' +\
7376            'tls_required: ' + repr(self.tls_required) + ' ' +\
7377            'username: ' + repr(self.username) + ' ' +\
7378            '>'
7379
7380    def to_dict(self):
7381        return {
7382            'auth_database': self.auth_database,
7383            'bind_interface': self.bind_interface,
7384            'egress_filter': self.egress_filter,
7385            'healthy': self.healthy,
7386            'hostname': self.hostname,
7387            'id': self.id,
7388            'name': self.name,
7389            'password': self.password,
7390            'port': self.port,
7391            'port_override': self.port_override,
7392            'secret_store_id': self.secret_store_id,
7393            'tags': self.tags,
7394            'tls_required': self.tls_required,
7395            'username': self.username,
7396        }
7397
7398    @classmethod
7399    def from_dict(cls, d):
7400        return cls(
7401            auth_database=d.get('auth_database'),
7402            bind_interface=d.get('bind_interface'),
7403            egress_filter=d.get('egress_filter'),
7404            healthy=d.get('healthy'),
7405            hostname=d.get('hostname'),
7406            id=d.get('id'),
7407            name=d.get('name'),
7408            password=d.get('password'),
7409            port=d.get('port'),
7410            port_override=d.get('port_override'),
7411            secret_store_id=d.get('secret_store_id'),
7412            tags=d.get('tags'),
7413            tls_required=d.get('tls_required'),
7414            username=d.get('username'),
7415        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7309    def __init__(
7310        self,
7311        auth_database=None,
7312        bind_interface=None,
7313        egress_filter=None,
7314        healthy=None,
7315        hostname=None,
7316        id=None,
7317        name=None,
7318        password=None,
7319        port=None,
7320        port_override=None,
7321        secret_store_id=None,
7322        tags=None,
7323        tls_required=None,
7324        username=None,
7325    ):
7326        self.auth_database = auth_database if auth_database is not None else ''
7327        self.bind_interface = bind_interface if bind_interface is not None else ''
7328        '''
7329         Bind interface
7330        '''
7331        self.egress_filter = egress_filter if egress_filter is not None else ''
7332        '''
7333         A filter applied to the routing logic to pin datasource to nodes.
7334        '''
7335        self.healthy = healthy if healthy is not None else False
7336        '''
7337         True if the datasource is reachable and the credentials are valid.
7338        '''
7339        self.hostname = hostname if hostname is not None else ''
7340        self.id = id if id is not None else ''
7341        '''
7342         Unique identifier of the Resource.
7343        '''
7344        self.name = name if name is not None else ''
7345        '''
7346         Unique human-readable name of the Resource.
7347        '''
7348        self.password = password if password is not None else ''
7349        self.port = port if port is not None else 0
7350        self.port_override = port_override if port_override is not None else 0
7351        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7352        '''
7353         ID of the secret store containing credentials for this resource, if any.
7354        '''
7355        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7356        '''
7357         Tags is a map of key, value pairs.
7358        '''
7359        self.tls_required = tls_required if tls_required is not None else False
7360        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7380    def to_dict(self):
7381        return {
7382            'auth_database': self.auth_database,
7383            'bind_interface': self.bind_interface,
7384            'egress_filter': self.egress_filter,
7385            'healthy': self.healthy,
7386            'hostname': self.hostname,
7387            'id': self.id,
7388            'name': self.name,
7389            'password': self.password,
7390            'port': self.port,
7391            'port_override': self.port_override,
7392            'secret_store_id': self.secret_store_id,
7393            'tags': self.tags,
7394            'tls_required': self.tls_required,
7395            'username': self.username,
7396        }
@classmethod
def from_dict(cls, d)
7398    @classmethod
7399    def from_dict(cls, d):
7400        return cls(
7401            auth_database=d.get('auth_database'),
7402            bind_interface=d.get('bind_interface'),
7403            egress_filter=d.get('egress_filter'),
7404            healthy=d.get('healthy'),
7405            hostname=d.get('hostname'),
7406            id=d.get('id'),
7407            name=d.get('name'),
7408            password=d.get('password'),
7409            port=d.get('port'),
7410            port_override=d.get('port_override'),
7411            secret_store_id=d.get('secret_store_id'),
7412            tags=d.get('tags'),
7413            tls_required=d.get('tls_required'),
7414            username=d.get('username'),
7415        )
class MongoLegacyHost:
7418class MongoLegacyHost:
7419    __slots__ = [
7420        'auth_database',
7421        'bind_interface',
7422        'egress_filter',
7423        'healthy',
7424        'hostname',
7425        'id',
7426        'name',
7427        'password',
7428        'port',
7429        'port_override',
7430        'replica_set',
7431        'secret_store_id',
7432        'tags',
7433        'tls_required',
7434        'username',
7435    ]
7436
7437    def __init__(
7438        self,
7439        auth_database=None,
7440        bind_interface=None,
7441        egress_filter=None,
7442        healthy=None,
7443        hostname=None,
7444        id=None,
7445        name=None,
7446        password=None,
7447        port=None,
7448        port_override=None,
7449        replica_set=None,
7450        secret_store_id=None,
7451        tags=None,
7452        tls_required=None,
7453        username=None,
7454    ):
7455        self.auth_database = auth_database if auth_database is not None else ''
7456        self.bind_interface = bind_interface if bind_interface is not None else ''
7457        '''
7458         Bind interface
7459        '''
7460        self.egress_filter = egress_filter if egress_filter is not None else ''
7461        '''
7462         A filter applied to the routing logic to pin datasource to nodes.
7463        '''
7464        self.healthy = healthy if healthy is not None else False
7465        '''
7466         True if the datasource is reachable and the credentials are valid.
7467        '''
7468        self.hostname = hostname if hostname is not None else ''
7469        self.id = id if id is not None else ''
7470        '''
7471         Unique identifier of the Resource.
7472        '''
7473        self.name = name if name is not None else ''
7474        '''
7475         Unique human-readable name of the Resource.
7476        '''
7477        self.password = password if password is not None else ''
7478        self.port = port if port is not None else 0
7479        self.port_override = port_override if port_override is not None else 0
7480        self.replica_set = replica_set if replica_set is not None else ''
7481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7482        '''
7483         ID of the secret store containing credentials for this resource, if any.
7484        '''
7485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7486        '''
7487         Tags is a map of key, value pairs.
7488        '''
7489        self.tls_required = tls_required if tls_required is not None else False
7490        self.username = username if username is not None else ''
7491
7492    def __repr__(self):
7493        return '<sdm.MongoLegacyHost ' + \
7494            'auth_database: ' + repr(self.auth_database) + ' ' +\
7495            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7496            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7497            'healthy: ' + repr(self.healthy) + ' ' +\
7498            'hostname: ' + repr(self.hostname) + ' ' +\
7499            'id: ' + repr(self.id) + ' ' +\
7500            'name: ' + repr(self.name) + ' ' +\
7501            'password: ' + repr(self.password) + ' ' +\
7502            'port: ' + repr(self.port) + ' ' +\
7503            'port_override: ' + repr(self.port_override) + ' ' +\
7504            'replica_set: ' + repr(self.replica_set) + ' ' +\
7505            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7506            'tags: ' + repr(self.tags) + ' ' +\
7507            'tls_required: ' + repr(self.tls_required) + ' ' +\
7508            'username: ' + repr(self.username) + ' ' +\
7509            '>'
7510
7511    def to_dict(self):
7512        return {
7513            'auth_database': self.auth_database,
7514            'bind_interface': self.bind_interface,
7515            'egress_filter': self.egress_filter,
7516            'healthy': self.healthy,
7517            'hostname': self.hostname,
7518            'id': self.id,
7519            'name': self.name,
7520            'password': self.password,
7521            'port': self.port,
7522            'port_override': self.port_override,
7523            'replica_set': self.replica_set,
7524            'secret_store_id': self.secret_store_id,
7525            'tags': self.tags,
7526            'tls_required': self.tls_required,
7527            'username': self.username,
7528        }
7529
7530    @classmethod
7531    def from_dict(cls, d):
7532        return cls(
7533            auth_database=d.get('auth_database'),
7534            bind_interface=d.get('bind_interface'),
7535            egress_filter=d.get('egress_filter'),
7536            healthy=d.get('healthy'),
7537            hostname=d.get('hostname'),
7538            id=d.get('id'),
7539            name=d.get('name'),
7540            password=d.get('password'),
7541            port=d.get('port'),
7542            port_override=d.get('port_override'),
7543            replica_set=d.get('replica_set'),
7544            secret_store_id=d.get('secret_store_id'),
7545            tags=d.get('tags'),
7546            tls_required=d.get('tls_required'),
7547            username=d.get('username'),
7548        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7437    def __init__(
7438        self,
7439        auth_database=None,
7440        bind_interface=None,
7441        egress_filter=None,
7442        healthy=None,
7443        hostname=None,
7444        id=None,
7445        name=None,
7446        password=None,
7447        port=None,
7448        port_override=None,
7449        replica_set=None,
7450        secret_store_id=None,
7451        tags=None,
7452        tls_required=None,
7453        username=None,
7454    ):
7455        self.auth_database = auth_database if auth_database is not None else ''
7456        self.bind_interface = bind_interface if bind_interface is not None else ''
7457        '''
7458         Bind interface
7459        '''
7460        self.egress_filter = egress_filter if egress_filter is not None else ''
7461        '''
7462         A filter applied to the routing logic to pin datasource to nodes.
7463        '''
7464        self.healthy = healthy if healthy is not None else False
7465        '''
7466         True if the datasource is reachable and the credentials are valid.
7467        '''
7468        self.hostname = hostname if hostname is not None else ''
7469        self.id = id if id is not None else ''
7470        '''
7471         Unique identifier of the Resource.
7472        '''
7473        self.name = name if name is not None else ''
7474        '''
7475         Unique human-readable name of the Resource.
7476        '''
7477        self.password = password if password is not None else ''
7478        self.port = port if port is not None else 0
7479        self.port_override = port_override if port_override is not None else 0
7480        self.replica_set = replica_set if replica_set is not None else ''
7481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7482        '''
7483         ID of the secret store containing credentials for this resource, if any.
7484        '''
7485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7486        '''
7487         Tags is a map of key, value pairs.
7488        '''
7489        self.tls_required = tls_required if tls_required is not None else False
7490        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7511    def to_dict(self):
7512        return {
7513            'auth_database': self.auth_database,
7514            'bind_interface': self.bind_interface,
7515            'egress_filter': self.egress_filter,
7516            'healthy': self.healthy,
7517            'hostname': self.hostname,
7518            'id': self.id,
7519            'name': self.name,
7520            'password': self.password,
7521            'port': self.port,
7522            'port_override': self.port_override,
7523            'replica_set': self.replica_set,
7524            'secret_store_id': self.secret_store_id,
7525            'tags': self.tags,
7526            'tls_required': self.tls_required,
7527            'username': self.username,
7528        }
@classmethod
def from_dict(cls, d)
7530    @classmethod
7531    def from_dict(cls, d):
7532        return cls(
7533            auth_database=d.get('auth_database'),
7534            bind_interface=d.get('bind_interface'),
7535            egress_filter=d.get('egress_filter'),
7536            healthy=d.get('healthy'),
7537            hostname=d.get('hostname'),
7538            id=d.get('id'),
7539            name=d.get('name'),
7540            password=d.get('password'),
7541            port=d.get('port'),
7542            port_override=d.get('port_override'),
7543            replica_set=d.get('replica_set'),
7544            secret_store_id=d.get('secret_store_id'),
7545            tags=d.get('tags'),
7546            tls_required=d.get('tls_required'),
7547            username=d.get('username'),
7548        )
class MongoLegacyReplicaset:
7551class MongoLegacyReplicaset:
7552    __slots__ = [
7553        'auth_database',
7554        'bind_interface',
7555        'connect_to_replica',
7556        'egress_filter',
7557        'healthy',
7558        'hostname',
7559        'id',
7560        'name',
7561        'password',
7562        'port',
7563        'port_override',
7564        'replica_set',
7565        'secret_store_id',
7566        'tags',
7567        'tls_required',
7568        'username',
7569    ]
7570
7571    def __init__(
7572        self,
7573        auth_database=None,
7574        bind_interface=None,
7575        connect_to_replica=None,
7576        egress_filter=None,
7577        healthy=None,
7578        hostname=None,
7579        id=None,
7580        name=None,
7581        password=None,
7582        port=None,
7583        port_override=None,
7584        replica_set=None,
7585        secret_store_id=None,
7586        tags=None,
7587        tls_required=None,
7588        username=None,
7589    ):
7590        self.auth_database = auth_database if auth_database is not None else ''
7591        self.bind_interface = bind_interface if bind_interface is not None else ''
7592        '''
7593         Bind interface
7594        '''
7595        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7596        self.egress_filter = egress_filter if egress_filter is not None else ''
7597        '''
7598         A filter applied to the routing logic to pin datasource to nodes.
7599        '''
7600        self.healthy = healthy if healthy is not None else False
7601        '''
7602         True if the datasource is reachable and the credentials are valid.
7603        '''
7604        self.hostname = hostname if hostname is not None else ''
7605        self.id = id if id is not None else ''
7606        '''
7607         Unique identifier of the Resource.
7608        '''
7609        self.name = name if name is not None else ''
7610        '''
7611         Unique human-readable name of the Resource.
7612        '''
7613        self.password = password if password is not None else ''
7614        self.port = port if port is not None else 0
7615        self.port_override = port_override if port_override is not None else 0
7616        self.replica_set = replica_set if replica_set is not None else ''
7617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7618        '''
7619         ID of the secret store containing credentials for this resource, if any.
7620        '''
7621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7622        '''
7623         Tags is a map of key, value pairs.
7624        '''
7625        self.tls_required = tls_required if tls_required is not None else False
7626        self.username = username if username is not None else ''
7627
7628    def __repr__(self):
7629        return '<sdm.MongoLegacyReplicaset ' + \
7630            'auth_database: ' + repr(self.auth_database) + ' ' +\
7631            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7632            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7633            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7634            'healthy: ' + repr(self.healthy) + ' ' +\
7635            'hostname: ' + repr(self.hostname) + ' ' +\
7636            'id: ' + repr(self.id) + ' ' +\
7637            'name: ' + repr(self.name) + ' ' +\
7638            'password: ' + repr(self.password) + ' ' +\
7639            'port: ' + repr(self.port) + ' ' +\
7640            'port_override: ' + repr(self.port_override) + ' ' +\
7641            'replica_set: ' + repr(self.replica_set) + ' ' +\
7642            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7643            'tags: ' + repr(self.tags) + ' ' +\
7644            'tls_required: ' + repr(self.tls_required) + ' ' +\
7645            'username: ' + repr(self.username) + ' ' +\
7646            '>'
7647
7648    def to_dict(self):
7649        return {
7650            'auth_database': self.auth_database,
7651            'bind_interface': self.bind_interface,
7652            'connect_to_replica': self.connect_to_replica,
7653            'egress_filter': self.egress_filter,
7654            'healthy': self.healthy,
7655            'hostname': self.hostname,
7656            'id': self.id,
7657            'name': self.name,
7658            'password': self.password,
7659            'port': self.port,
7660            'port_override': self.port_override,
7661            'replica_set': self.replica_set,
7662            'secret_store_id': self.secret_store_id,
7663            'tags': self.tags,
7664            'tls_required': self.tls_required,
7665            'username': self.username,
7666        }
7667
7668    @classmethod
7669    def from_dict(cls, d):
7670        return cls(
7671            auth_database=d.get('auth_database'),
7672            bind_interface=d.get('bind_interface'),
7673            connect_to_replica=d.get('connect_to_replica'),
7674            egress_filter=d.get('egress_filter'),
7675            healthy=d.get('healthy'),
7676            hostname=d.get('hostname'),
7677            id=d.get('id'),
7678            name=d.get('name'),
7679            password=d.get('password'),
7680            port=d.get('port'),
7681            port_override=d.get('port_override'),
7682            replica_set=d.get('replica_set'),
7683            secret_store_id=d.get('secret_store_id'),
7684            tags=d.get('tags'),
7685            tls_required=d.get('tls_required'),
7686            username=d.get('username'),
7687        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7571    def __init__(
7572        self,
7573        auth_database=None,
7574        bind_interface=None,
7575        connect_to_replica=None,
7576        egress_filter=None,
7577        healthy=None,
7578        hostname=None,
7579        id=None,
7580        name=None,
7581        password=None,
7582        port=None,
7583        port_override=None,
7584        replica_set=None,
7585        secret_store_id=None,
7586        tags=None,
7587        tls_required=None,
7588        username=None,
7589    ):
7590        self.auth_database = auth_database if auth_database is not None else ''
7591        self.bind_interface = bind_interface if bind_interface is not None else ''
7592        '''
7593         Bind interface
7594        '''
7595        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7596        self.egress_filter = egress_filter if egress_filter is not None else ''
7597        '''
7598         A filter applied to the routing logic to pin datasource to nodes.
7599        '''
7600        self.healthy = healthy if healthy is not None else False
7601        '''
7602         True if the datasource is reachable and the credentials are valid.
7603        '''
7604        self.hostname = hostname if hostname is not None else ''
7605        self.id = id if id is not None else ''
7606        '''
7607         Unique identifier of the Resource.
7608        '''
7609        self.name = name if name is not None else ''
7610        '''
7611         Unique human-readable name of the Resource.
7612        '''
7613        self.password = password if password is not None else ''
7614        self.port = port if port is not None else 0
7615        self.port_override = port_override if port_override is not None else 0
7616        self.replica_set = replica_set if replica_set is not None else ''
7617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7618        '''
7619         ID of the secret store containing credentials for this resource, if any.
7620        '''
7621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7622        '''
7623         Tags is a map of key, value pairs.
7624        '''
7625        self.tls_required = tls_required if tls_required is not None else False
7626        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7648    def to_dict(self):
7649        return {
7650            'auth_database': self.auth_database,
7651            'bind_interface': self.bind_interface,
7652            'connect_to_replica': self.connect_to_replica,
7653            'egress_filter': self.egress_filter,
7654            'healthy': self.healthy,
7655            'hostname': self.hostname,
7656            'id': self.id,
7657            'name': self.name,
7658            'password': self.password,
7659            'port': self.port,
7660            'port_override': self.port_override,
7661            'replica_set': self.replica_set,
7662            'secret_store_id': self.secret_store_id,
7663            'tags': self.tags,
7664            'tls_required': self.tls_required,
7665            'username': self.username,
7666        }
@classmethod
def from_dict(cls, d)
7668    @classmethod
7669    def from_dict(cls, d):
7670        return cls(
7671            auth_database=d.get('auth_database'),
7672            bind_interface=d.get('bind_interface'),
7673            connect_to_replica=d.get('connect_to_replica'),
7674            egress_filter=d.get('egress_filter'),
7675            healthy=d.get('healthy'),
7676            hostname=d.get('hostname'),
7677            id=d.get('id'),
7678            name=d.get('name'),
7679            password=d.get('password'),
7680            port=d.get('port'),
7681            port_override=d.get('port_override'),
7682            replica_set=d.get('replica_set'),
7683            secret_store_id=d.get('secret_store_id'),
7684            tags=d.get('tags'),
7685            tls_required=d.get('tls_required'),
7686            username=d.get('username'),
7687        )
class MongoReplicaSet:
7690class MongoReplicaSet:
7691    '''
7692    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7693    without a major version bump.
7694    '''
7695    __slots__ = [
7696        'auth_database',
7697        'bind_interface',
7698        'connect_to_replica',
7699        'egress_filter',
7700        'healthy',
7701        'hostname',
7702        'id',
7703        'name',
7704        'password',
7705        'port',
7706        'port_override',
7707        'replica_set',
7708        'secret_store_id',
7709        'tags',
7710        'tls_required',
7711        'username',
7712    ]
7713
7714    def __init__(
7715        self,
7716        auth_database=None,
7717        bind_interface=None,
7718        connect_to_replica=None,
7719        egress_filter=None,
7720        healthy=None,
7721        hostname=None,
7722        id=None,
7723        name=None,
7724        password=None,
7725        port=None,
7726        port_override=None,
7727        replica_set=None,
7728        secret_store_id=None,
7729        tags=None,
7730        tls_required=None,
7731        username=None,
7732    ):
7733        self.auth_database = auth_database if auth_database is not None else ''
7734        self.bind_interface = bind_interface if bind_interface is not None else ''
7735        '''
7736         Bind interface
7737        '''
7738        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7739        self.egress_filter = egress_filter if egress_filter is not None else ''
7740        '''
7741         A filter applied to the routing logic to pin datasource to nodes.
7742        '''
7743        self.healthy = healthy if healthy is not None else False
7744        '''
7745         True if the datasource is reachable and the credentials are valid.
7746        '''
7747        self.hostname = hostname if hostname is not None else ''
7748        self.id = id if id is not None else ''
7749        '''
7750         Unique identifier of the Resource.
7751        '''
7752        self.name = name if name is not None else ''
7753        '''
7754         Unique human-readable name of the Resource.
7755        '''
7756        self.password = password if password is not None else ''
7757        self.port = port if port is not None else 0
7758        self.port_override = port_override if port_override is not None else 0
7759        self.replica_set = replica_set if replica_set is not None else ''
7760        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7761        '''
7762         ID of the secret store containing credentials for this resource, if any.
7763        '''
7764        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7765        '''
7766         Tags is a map of key, value pairs.
7767        '''
7768        self.tls_required = tls_required if tls_required is not None else False
7769        self.username = username if username is not None else ''
7770
7771    def __repr__(self):
7772        return '<sdm.MongoReplicaSet ' + \
7773            'auth_database: ' + repr(self.auth_database) + ' ' +\
7774            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7775            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7776            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7777            'healthy: ' + repr(self.healthy) + ' ' +\
7778            'hostname: ' + repr(self.hostname) + ' ' +\
7779            'id: ' + repr(self.id) + ' ' +\
7780            'name: ' + repr(self.name) + ' ' +\
7781            'password: ' + repr(self.password) + ' ' +\
7782            'port: ' + repr(self.port) + ' ' +\
7783            'port_override: ' + repr(self.port_override) + ' ' +\
7784            'replica_set: ' + repr(self.replica_set) + ' ' +\
7785            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7786            'tags: ' + repr(self.tags) + ' ' +\
7787            'tls_required: ' + repr(self.tls_required) + ' ' +\
7788            'username: ' + repr(self.username) + ' ' +\
7789            '>'
7790
7791    def to_dict(self):
7792        return {
7793            'auth_database': self.auth_database,
7794            'bind_interface': self.bind_interface,
7795            'connect_to_replica': self.connect_to_replica,
7796            'egress_filter': self.egress_filter,
7797            'healthy': self.healthy,
7798            'hostname': self.hostname,
7799            'id': self.id,
7800            'name': self.name,
7801            'password': self.password,
7802            'port': self.port,
7803            'port_override': self.port_override,
7804            'replica_set': self.replica_set,
7805            'secret_store_id': self.secret_store_id,
7806            'tags': self.tags,
7807            'tls_required': self.tls_required,
7808            'username': self.username,
7809        }
7810
7811    @classmethod
7812    def from_dict(cls, d):
7813        return cls(
7814            auth_database=d.get('auth_database'),
7815            bind_interface=d.get('bind_interface'),
7816            connect_to_replica=d.get('connect_to_replica'),
7817            egress_filter=d.get('egress_filter'),
7818            healthy=d.get('healthy'),
7819            hostname=d.get('hostname'),
7820            id=d.get('id'),
7821            name=d.get('name'),
7822            password=d.get('password'),
7823            port=d.get('port'),
7824            port_override=d.get('port_override'),
7825            replica_set=d.get('replica_set'),
7826            secret_store_id=d.get('secret_store_id'),
7827            tags=d.get('tags'),
7828            tls_required=d.get('tls_required'),
7829            username=d.get('username'),
7830        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7714    def __init__(
7715        self,
7716        auth_database=None,
7717        bind_interface=None,
7718        connect_to_replica=None,
7719        egress_filter=None,
7720        healthy=None,
7721        hostname=None,
7722        id=None,
7723        name=None,
7724        password=None,
7725        port=None,
7726        port_override=None,
7727        replica_set=None,
7728        secret_store_id=None,
7729        tags=None,
7730        tls_required=None,
7731        username=None,
7732    ):
7733        self.auth_database = auth_database if auth_database is not None else ''
7734        self.bind_interface = bind_interface if bind_interface is not None else ''
7735        '''
7736         Bind interface
7737        '''
7738        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7739        self.egress_filter = egress_filter if egress_filter is not None else ''
7740        '''
7741         A filter applied to the routing logic to pin datasource to nodes.
7742        '''
7743        self.healthy = healthy if healthy is not None else False
7744        '''
7745         True if the datasource is reachable and the credentials are valid.
7746        '''
7747        self.hostname = hostname if hostname is not None else ''
7748        self.id = id if id is not None else ''
7749        '''
7750         Unique identifier of the Resource.
7751        '''
7752        self.name = name if name is not None else ''
7753        '''
7754         Unique human-readable name of the Resource.
7755        '''
7756        self.password = password if password is not None else ''
7757        self.port = port if port is not None else 0
7758        self.port_override = port_override if port_override is not None else 0
7759        self.replica_set = replica_set if replica_set is not None else ''
7760        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7761        '''
7762         ID of the secret store containing credentials for this resource, if any.
7763        '''
7764        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7765        '''
7766         Tags is a map of key, value pairs.
7767        '''
7768        self.tls_required = tls_required if tls_required is not None else False
7769        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7791    def to_dict(self):
7792        return {
7793            'auth_database': self.auth_database,
7794            'bind_interface': self.bind_interface,
7795            'connect_to_replica': self.connect_to_replica,
7796            'egress_filter': self.egress_filter,
7797            'healthy': self.healthy,
7798            'hostname': self.hostname,
7799            'id': self.id,
7800            'name': self.name,
7801            'password': self.password,
7802            'port': self.port,
7803            'port_override': self.port_override,
7804            'replica_set': self.replica_set,
7805            'secret_store_id': self.secret_store_id,
7806            'tags': self.tags,
7807            'tls_required': self.tls_required,
7808            'username': self.username,
7809        }
@classmethod
def from_dict(cls, d)
7811    @classmethod
7812    def from_dict(cls, d):
7813        return cls(
7814            auth_database=d.get('auth_database'),
7815            bind_interface=d.get('bind_interface'),
7816            connect_to_replica=d.get('connect_to_replica'),
7817            egress_filter=d.get('egress_filter'),
7818            healthy=d.get('healthy'),
7819            hostname=d.get('hostname'),
7820            id=d.get('id'),
7821            name=d.get('name'),
7822            password=d.get('password'),
7823            port=d.get('port'),
7824            port_override=d.get('port_override'),
7825            replica_set=d.get('replica_set'),
7826            secret_store_id=d.get('secret_store_id'),
7827            tags=d.get('tags'),
7828            tls_required=d.get('tls_required'),
7829            username=d.get('username'),
7830        )
class MongoShardedCluster:
7833class MongoShardedCluster:
7834    '''
7835    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
7836    without a major version bump.
7837    '''
7838    __slots__ = [
7839        'auth_database',
7840        'bind_interface',
7841        'egress_filter',
7842        'healthy',
7843        'hostname',
7844        'id',
7845        'name',
7846        'password',
7847        'port_override',
7848        'secret_store_id',
7849        'tags',
7850        'tls_required',
7851        'username',
7852    ]
7853
7854    def __init__(
7855        self,
7856        auth_database=None,
7857        bind_interface=None,
7858        egress_filter=None,
7859        healthy=None,
7860        hostname=None,
7861        id=None,
7862        name=None,
7863        password=None,
7864        port_override=None,
7865        secret_store_id=None,
7866        tags=None,
7867        tls_required=None,
7868        username=None,
7869    ):
7870        self.auth_database = auth_database if auth_database is not None else ''
7871        self.bind_interface = bind_interface if bind_interface is not None else ''
7872        '''
7873         Bind interface
7874        '''
7875        self.egress_filter = egress_filter if egress_filter is not None else ''
7876        '''
7877         A filter applied to the routing logic to pin datasource to nodes.
7878        '''
7879        self.healthy = healthy if healthy is not None else False
7880        '''
7881         True if the datasource is reachable and the credentials are valid.
7882        '''
7883        self.hostname = hostname if hostname is not None else ''
7884        self.id = id if id is not None else ''
7885        '''
7886         Unique identifier of the Resource.
7887        '''
7888        self.name = name if name is not None else ''
7889        '''
7890         Unique human-readable name of the Resource.
7891        '''
7892        self.password = password if password is not None else ''
7893        self.port_override = port_override if port_override is not None else 0
7894        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7895        '''
7896         ID of the secret store containing credentials for this resource, if any.
7897        '''
7898        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7899        '''
7900         Tags is a map of key, value pairs.
7901        '''
7902        self.tls_required = tls_required if tls_required is not None else False
7903        self.username = username if username is not None else ''
7904
7905    def __repr__(self):
7906        return '<sdm.MongoShardedCluster ' + \
7907            'auth_database: ' + repr(self.auth_database) + ' ' +\
7908            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7909            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7910            'healthy: ' + repr(self.healthy) + ' ' +\
7911            'hostname: ' + repr(self.hostname) + ' ' +\
7912            'id: ' + repr(self.id) + ' ' +\
7913            'name: ' + repr(self.name) + ' ' +\
7914            'password: ' + repr(self.password) + ' ' +\
7915            'port_override: ' + repr(self.port_override) + ' ' +\
7916            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7917            'tags: ' + repr(self.tags) + ' ' +\
7918            'tls_required: ' + repr(self.tls_required) + ' ' +\
7919            'username: ' + repr(self.username) + ' ' +\
7920            '>'
7921
7922    def to_dict(self):
7923        return {
7924            'auth_database': self.auth_database,
7925            'bind_interface': self.bind_interface,
7926            'egress_filter': self.egress_filter,
7927            'healthy': self.healthy,
7928            'hostname': self.hostname,
7929            'id': self.id,
7930            'name': self.name,
7931            'password': self.password,
7932            'port_override': self.port_override,
7933            'secret_store_id': self.secret_store_id,
7934            'tags': self.tags,
7935            'tls_required': self.tls_required,
7936            'username': self.username,
7937        }
7938
7939    @classmethod
7940    def from_dict(cls, d):
7941        return cls(
7942            auth_database=d.get('auth_database'),
7943            bind_interface=d.get('bind_interface'),
7944            egress_filter=d.get('egress_filter'),
7945            healthy=d.get('healthy'),
7946            hostname=d.get('hostname'),
7947            id=d.get('id'),
7948            name=d.get('name'),
7949            password=d.get('password'),
7950            port_override=d.get('port_override'),
7951            secret_store_id=d.get('secret_store_id'),
7952            tags=d.get('tags'),
7953            tls_required=d.get('tls_required'),
7954            username=d.get('username'),
7955        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7854    def __init__(
7855        self,
7856        auth_database=None,
7857        bind_interface=None,
7858        egress_filter=None,
7859        healthy=None,
7860        hostname=None,
7861        id=None,
7862        name=None,
7863        password=None,
7864        port_override=None,
7865        secret_store_id=None,
7866        tags=None,
7867        tls_required=None,
7868        username=None,
7869    ):
7870        self.auth_database = auth_database if auth_database is not None else ''
7871        self.bind_interface = bind_interface if bind_interface is not None else ''
7872        '''
7873         Bind interface
7874        '''
7875        self.egress_filter = egress_filter if egress_filter is not None else ''
7876        '''
7877         A filter applied to the routing logic to pin datasource to nodes.
7878        '''
7879        self.healthy = healthy if healthy is not None else False
7880        '''
7881         True if the datasource is reachable and the credentials are valid.
7882        '''
7883        self.hostname = hostname if hostname is not None else ''
7884        self.id = id if id is not None else ''
7885        '''
7886         Unique identifier of the Resource.
7887        '''
7888        self.name = name if name is not None else ''
7889        '''
7890         Unique human-readable name of the Resource.
7891        '''
7892        self.password = password if password is not None else ''
7893        self.port_override = port_override if port_override is not None else 0
7894        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7895        '''
7896         ID of the secret store containing credentials for this resource, if any.
7897        '''
7898        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7899        '''
7900         Tags is a map of key, value pairs.
7901        '''
7902        self.tls_required = tls_required if tls_required is not None else False
7903        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7922    def to_dict(self):
7923        return {
7924            'auth_database': self.auth_database,
7925            'bind_interface': self.bind_interface,
7926            'egress_filter': self.egress_filter,
7927            'healthy': self.healthy,
7928            'hostname': self.hostname,
7929            'id': self.id,
7930            'name': self.name,
7931            'password': self.password,
7932            'port_override': self.port_override,
7933            'secret_store_id': self.secret_store_id,
7934            'tags': self.tags,
7935            'tls_required': self.tls_required,
7936            'username': self.username,
7937        }
@classmethod
def from_dict(cls, d)
7939    @classmethod
7940    def from_dict(cls, d):
7941        return cls(
7942            auth_database=d.get('auth_database'),
7943            bind_interface=d.get('bind_interface'),
7944            egress_filter=d.get('egress_filter'),
7945            healthy=d.get('healthy'),
7946            hostname=d.get('hostname'),
7947            id=d.get('id'),
7948            name=d.get('name'),
7949            password=d.get('password'),
7950            port_override=d.get('port_override'),
7951            secret_store_id=d.get('secret_store_id'),
7952            tags=d.get('tags'),
7953            tls_required=d.get('tls_required'),
7954            username=d.get('username'),
7955        )
class Mysql:
7958class Mysql:
7959    __slots__ = [
7960        'bind_interface',
7961        'database',
7962        'egress_filter',
7963        'healthy',
7964        'hostname',
7965        'id',
7966        'name',
7967        'password',
7968        'port',
7969        'port_override',
7970        'secret_store_id',
7971        'tags',
7972        'username',
7973    ]
7974
7975    def __init__(
7976        self,
7977        bind_interface=None,
7978        database=None,
7979        egress_filter=None,
7980        healthy=None,
7981        hostname=None,
7982        id=None,
7983        name=None,
7984        password=None,
7985        port=None,
7986        port_override=None,
7987        secret_store_id=None,
7988        tags=None,
7989        username=None,
7990    ):
7991        self.bind_interface = bind_interface if bind_interface is not None else ''
7992        '''
7993         Bind interface
7994        '''
7995        self.database = database if database is not None else ''
7996        self.egress_filter = egress_filter if egress_filter is not None else ''
7997        '''
7998         A filter applied to the routing logic to pin datasource to nodes.
7999        '''
8000        self.healthy = healthy if healthy is not None else False
8001        '''
8002         True if the datasource is reachable and the credentials are valid.
8003        '''
8004        self.hostname = hostname if hostname is not None else ''
8005        self.id = id if id is not None else ''
8006        '''
8007         Unique identifier of the Resource.
8008        '''
8009        self.name = name if name is not None else ''
8010        '''
8011         Unique human-readable name of the Resource.
8012        '''
8013        self.password = password if password is not None else ''
8014        self.port = port if port is not None else 0
8015        self.port_override = port_override if port_override is not None else 0
8016        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8017        '''
8018         ID of the secret store containing credentials for this resource, if any.
8019        '''
8020        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8021        '''
8022         Tags is a map of key, value pairs.
8023        '''
8024        self.username = username if username is not None else ''
8025
8026    def __repr__(self):
8027        return '<sdm.Mysql ' + \
8028            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8029            'database: ' + repr(self.database) + ' ' +\
8030            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8031            'healthy: ' + repr(self.healthy) + ' ' +\
8032            'hostname: ' + repr(self.hostname) + ' ' +\
8033            'id: ' + repr(self.id) + ' ' +\
8034            'name: ' + repr(self.name) + ' ' +\
8035            'password: ' + repr(self.password) + ' ' +\
8036            'port: ' + repr(self.port) + ' ' +\
8037            'port_override: ' + repr(self.port_override) + ' ' +\
8038            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8039            'tags: ' + repr(self.tags) + ' ' +\
8040            'username: ' + repr(self.username) + ' ' +\
8041            '>'
8042
8043    def to_dict(self):
8044        return {
8045            'bind_interface': self.bind_interface,
8046            'database': self.database,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'secret_store_id': self.secret_store_id,
8056            'tags': self.tags,
8057            'username': self.username,
8058        }
8059
8060    @classmethod
8061    def from_dict(cls, d):
8062        return cls(
8063            bind_interface=d.get('bind_interface'),
8064            database=d.get('database'),
8065            egress_filter=d.get('egress_filter'),
8066            healthy=d.get('healthy'),
8067            hostname=d.get('hostname'),
8068            id=d.get('id'),
8069            name=d.get('name'),
8070            password=d.get('password'),
8071            port=d.get('port'),
8072            port_override=d.get('port_override'),
8073            secret_store_id=d.get('secret_store_id'),
8074            tags=d.get('tags'),
8075            username=d.get('username'),
8076        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7975    def __init__(
7976        self,
7977        bind_interface=None,
7978        database=None,
7979        egress_filter=None,
7980        healthy=None,
7981        hostname=None,
7982        id=None,
7983        name=None,
7984        password=None,
7985        port=None,
7986        port_override=None,
7987        secret_store_id=None,
7988        tags=None,
7989        username=None,
7990    ):
7991        self.bind_interface = bind_interface if bind_interface is not None else ''
7992        '''
7993         Bind interface
7994        '''
7995        self.database = database if database is not None else ''
7996        self.egress_filter = egress_filter if egress_filter is not None else ''
7997        '''
7998         A filter applied to the routing logic to pin datasource to nodes.
7999        '''
8000        self.healthy = healthy if healthy is not None else False
8001        '''
8002         True if the datasource is reachable and the credentials are valid.
8003        '''
8004        self.hostname = hostname if hostname is not None else ''
8005        self.id = id if id is not None else ''
8006        '''
8007         Unique identifier of the Resource.
8008        '''
8009        self.name = name if name is not None else ''
8010        '''
8011         Unique human-readable name of the Resource.
8012        '''
8013        self.password = password if password is not None else ''
8014        self.port = port if port is not None else 0
8015        self.port_override = port_override if port_override is not None else 0
8016        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8017        '''
8018         ID of the secret store containing credentials for this resource, if any.
8019        '''
8020        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8021        '''
8022         Tags is a map of key, value pairs.
8023        '''
8024        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8043    def to_dict(self):
8044        return {
8045            'bind_interface': self.bind_interface,
8046            'database': self.database,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'secret_store_id': self.secret_store_id,
8056            'tags': self.tags,
8057            'username': self.username,
8058        }
@classmethod
def from_dict(cls, d)
8060    @classmethod
8061    def from_dict(cls, d):
8062        return cls(
8063            bind_interface=d.get('bind_interface'),
8064            database=d.get('database'),
8065            egress_filter=d.get('egress_filter'),
8066            healthy=d.get('healthy'),
8067            hostname=d.get('hostname'),
8068            id=d.get('id'),
8069            name=d.get('name'),
8070            password=d.get('password'),
8071            port=d.get('port'),
8072            port_override=d.get('port_override'),
8073            secret_store_id=d.get('secret_store_id'),
8074            tags=d.get('tags'),
8075            username=d.get('username'),
8076        )
class Neptune:
8079class Neptune:
8080    __slots__ = [
8081        'bind_interface',
8082        'egress_filter',
8083        'endpoint',
8084        'healthy',
8085        'id',
8086        'name',
8087        'port',
8088        'port_override',
8089        'secret_store_id',
8090        'tags',
8091    ]
8092
8093    def __init__(
8094        self,
8095        bind_interface=None,
8096        egress_filter=None,
8097        endpoint=None,
8098        healthy=None,
8099        id=None,
8100        name=None,
8101        port=None,
8102        port_override=None,
8103        secret_store_id=None,
8104        tags=None,
8105    ):
8106        self.bind_interface = bind_interface if bind_interface is not None else ''
8107        '''
8108         Bind interface
8109        '''
8110        self.egress_filter = egress_filter if egress_filter is not None else ''
8111        '''
8112         A filter applied to the routing logic to pin datasource to nodes.
8113        '''
8114        self.endpoint = endpoint if endpoint is not None else ''
8115        self.healthy = healthy if healthy is not None else False
8116        '''
8117         True if the datasource is reachable and the credentials are valid.
8118        '''
8119        self.id = id if id is not None else ''
8120        '''
8121         Unique identifier of the Resource.
8122        '''
8123        self.name = name if name is not None else ''
8124        '''
8125         Unique human-readable name of the Resource.
8126        '''
8127        self.port = port if port is not None else 0
8128        self.port_override = port_override if port_override is not None else 0
8129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8130        '''
8131         ID of the secret store containing credentials for this resource, if any.
8132        '''
8133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8134        '''
8135         Tags is a map of key, value pairs.
8136        '''
8137
8138    def __repr__(self):
8139        return '<sdm.Neptune ' + \
8140            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8141            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8142            'endpoint: ' + repr(self.endpoint) + ' ' +\
8143            'healthy: ' + repr(self.healthy) + ' ' +\
8144            'id: ' + repr(self.id) + ' ' +\
8145            'name: ' + repr(self.name) + ' ' +\
8146            'port: ' + repr(self.port) + ' ' +\
8147            'port_override: ' + repr(self.port_override) + ' ' +\
8148            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8149            'tags: ' + repr(self.tags) + ' ' +\
8150            '>'
8151
8152    def to_dict(self):
8153        return {
8154            'bind_interface': self.bind_interface,
8155            'egress_filter': self.egress_filter,
8156            'endpoint': self.endpoint,
8157            'healthy': self.healthy,
8158            'id': self.id,
8159            'name': self.name,
8160            'port': self.port,
8161            'port_override': self.port_override,
8162            'secret_store_id': self.secret_store_id,
8163            'tags': self.tags,
8164        }
8165
8166    @classmethod
8167    def from_dict(cls, d):
8168        return cls(
8169            bind_interface=d.get('bind_interface'),
8170            egress_filter=d.get('egress_filter'),
8171            endpoint=d.get('endpoint'),
8172            healthy=d.get('healthy'),
8173            id=d.get('id'),
8174            name=d.get('name'),
8175            port=d.get('port'),
8176            port_override=d.get('port_override'),
8177            secret_store_id=d.get('secret_store_id'),
8178            tags=d.get('tags'),
8179        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8093    def __init__(
8094        self,
8095        bind_interface=None,
8096        egress_filter=None,
8097        endpoint=None,
8098        healthy=None,
8099        id=None,
8100        name=None,
8101        port=None,
8102        port_override=None,
8103        secret_store_id=None,
8104        tags=None,
8105    ):
8106        self.bind_interface = bind_interface if bind_interface is not None else ''
8107        '''
8108         Bind interface
8109        '''
8110        self.egress_filter = egress_filter if egress_filter is not None else ''
8111        '''
8112         A filter applied to the routing logic to pin datasource to nodes.
8113        '''
8114        self.endpoint = endpoint if endpoint is not None else ''
8115        self.healthy = healthy if healthy is not None else False
8116        '''
8117         True if the datasource is reachable and the credentials are valid.
8118        '''
8119        self.id = id if id is not None else ''
8120        '''
8121         Unique identifier of the Resource.
8122        '''
8123        self.name = name if name is not None else ''
8124        '''
8125         Unique human-readable name of the Resource.
8126        '''
8127        self.port = port if port is not None else 0
8128        self.port_override = port_override if port_override is not None else 0
8129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8130        '''
8131         ID of the secret store containing credentials for this resource, if any.
8132        '''
8133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8134        '''
8135         Tags is a map of key, value pairs.
8136        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8152    def to_dict(self):
8153        return {
8154            'bind_interface': self.bind_interface,
8155            'egress_filter': self.egress_filter,
8156            'endpoint': self.endpoint,
8157            'healthy': self.healthy,
8158            'id': self.id,
8159            'name': self.name,
8160            'port': self.port,
8161            'port_override': self.port_override,
8162            'secret_store_id': self.secret_store_id,
8163            'tags': self.tags,
8164        }
@classmethod
def from_dict(cls, d)
8166    @classmethod
8167    def from_dict(cls, d):
8168        return cls(
8169            bind_interface=d.get('bind_interface'),
8170            egress_filter=d.get('egress_filter'),
8171            endpoint=d.get('endpoint'),
8172            healthy=d.get('healthy'),
8173            id=d.get('id'),
8174            name=d.get('name'),
8175            port=d.get('port'),
8176            port_override=d.get('port_override'),
8177            secret_store_id=d.get('secret_store_id'),
8178            tags=d.get('tags'),
8179        )
class NeptuneIAM:
8182class NeptuneIAM:
8183    __slots__ = [
8184        'access_key',
8185        'bind_interface',
8186        'egress_filter',
8187        'endpoint',
8188        'healthy',
8189        'id',
8190        'name',
8191        'port',
8192        'port_override',
8193        'region',
8194        'role_arn',
8195        'role_external_id',
8196        'secret_access_key',
8197        'secret_store_id',
8198        'tags',
8199    ]
8200
8201    def __init__(
8202        self,
8203        access_key=None,
8204        bind_interface=None,
8205        egress_filter=None,
8206        endpoint=None,
8207        healthy=None,
8208        id=None,
8209        name=None,
8210        port=None,
8211        port_override=None,
8212        region=None,
8213        role_arn=None,
8214        role_external_id=None,
8215        secret_access_key=None,
8216        secret_store_id=None,
8217        tags=None,
8218    ):
8219        self.access_key = access_key if access_key is not None else ''
8220        self.bind_interface = bind_interface if bind_interface is not None else ''
8221        '''
8222         Bind interface
8223        '''
8224        self.egress_filter = egress_filter if egress_filter is not None else ''
8225        '''
8226         A filter applied to the routing logic to pin datasource to nodes.
8227        '''
8228        self.endpoint = endpoint if endpoint is not None else ''
8229        self.healthy = healthy if healthy is not None else False
8230        '''
8231         True if the datasource is reachable and the credentials are valid.
8232        '''
8233        self.id = id if id is not None else ''
8234        '''
8235         Unique identifier of the Resource.
8236        '''
8237        self.name = name if name is not None else ''
8238        '''
8239         Unique human-readable name of the Resource.
8240        '''
8241        self.port = port if port is not None else 0
8242        self.port_override = port_override if port_override is not None else 0
8243        self.region = region if region is not None else ''
8244        self.role_arn = role_arn if role_arn is not None else ''
8245        self.role_external_id = role_external_id if role_external_id is not None else ''
8246        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8247        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8248        '''
8249         ID of the secret store containing credentials for this resource, if any.
8250        '''
8251        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8252        '''
8253         Tags is a map of key, value pairs.
8254        '''
8255
8256    def __repr__(self):
8257        return '<sdm.NeptuneIAM ' + \
8258            'access_key: ' + repr(self.access_key) + ' ' +\
8259            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8260            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8261            'endpoint: ' + repr(self.endpoint) + ' ' +\
8262            'healthy: ' + repr(self.healthy) + ' ' +\
8263            'id: ' + repr(self.id) + ' ' +\
8264            'name: ' + repr(self.name) + ' ' +\
8265            'port: ' + repr(self.port) + ' ' +\
8266            'port_override: ' + repr(self.port_override) + ' ' +\
8267            'region: ' + repr(self.region) + ' ' +\
8268            'role_arn: ' + repr(self.role_arn) + ' ' +\
8269            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8270            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8271            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8272            'tags: ' + repr(self.tags) + ' ' +\
8273            '>'
8274
8275    def to_dict(self):
8276        return {
8277            'access_key': self.access_key,
8278            'bind_interface': self.bind_interface,
8279            'egress_filter': self.egress_filter,
8280            'endpoint': self.endpoint,
8281            'healthy': self.healthy,
8282            'id': self.id,
8283            'name': self.name,
8284            'port': self.port,
8285            'port_override': self.port_override,
8286            'region': self.region,
8287            'role_arn': self.role_arn,
8288            'role_external_id': self.role_external_id,
8289            'secret_access_key': self.secret_access_key,
8290            'secret_store_id': self.secret_store_id,
8291            'tags': self.tags,
8292        }
8293
8294    @classmethod
8295    def from_dict(cls, d):
8296        return cls(
8297            access_key=d.get('access_key'),
8298            bind_interface=d.get('bind_interface'),
8299            egress_filter=d.get('egress_filter'),
8300            endpoint=d.get('endpoint'),
8301            healthy=d.get('healthy'),
8302            id=d.get('id'),
8303            name=d.get('name'),
8304            port=d.get('port'),
8305            port_override=d.get('port_override'),
8306            region=d.get('region'),
8307            role_arn=d.get('role_arn'),
8308            role_external_id=d.get('role_external_id'),
8309            secret_access_key=d.get('secret_access_key'),
8310            secret_store_id=d.get('secret_store_id'),
8311            tags=d.get('tags'),
8312        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8201    def __init__(
8202        self,
8203        access_key=None,
8204        bind_interface=None,
8205        egress_filter=None,
8206        endpoint=None,
8207        healthy=None,
8208        id=None,
8209        name=None,
8210        port=None,
8211        port_override=None,
8212        region=None,
8213        role_arn=None,
8214        role_external_id=None,
8215        secret_access_key=None,
8216        secret_store_id=None,
8217        tags=None,
8218    ):
8219        self.access_key = access_key if access_key is not None else ''
8220        self.bind_interface = bind_interface if bind_interface is not None else ''
8221        '''
8222         Bind interface
8223        '''
8224        self.egress_filter = egress_filter if egress_filter is not None else ''
8225        '''
8226         A filter applied to the routing logic to pin datasource to nodes.
8227        '''
8228        self.endpoint = endpoint if endpoint is not None else ''
8229        self.healthy = healthy if healthy is not None else False
8230        '''
8231         True if the datasource is reachable and the credentials are valid.
8232        '''
8233        self.id = id if id is not None else ''
8234        '''
8235         Unique identifier of the Resource.
8236        '''
8237        self.name = name if name is not None else ''
8238        '''
8239         Unique human-readable name of the Resource.
8240        '''
8241        self.port = port if port is not None else 0
8242        self.port_override = port_override if port_override is not None else 0
8243        self.region = region if region is not None else ''
8244        self.role_arn = role_arn if role_arn is not None else ''
8245        self.role_external_id = role_external_id if role_external_id is not None else ''
8246        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8247        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8248        '''
8249         ID of the secret store containing credentials for this resource, if any.
8250        '''
8251        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8252        '''
8253         Tags is a map of key, value pairs.
8254        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8275    def to_dict(self):
8276        return {
8277            'access_key': self.access_key,
8278            'bind_interface': self.bind_interface,
8279            'egress_filter': self.egress_filter,
8280            'endpoint': self.endpoint,
8281            'healthy': self.healthy,
8282            'id': self.id,
8283            'name': self.name,
8284            'port': self.port,
8285            'port_override': self.port_override,
8286            'region': self.region,
8287            'role_arn': self.role_arn,
8288            'role_external_id': self.role_external_id,
8289            'secret_access_key': self.secret_access_key,
8290            'secret_store_id': self.secret_store_id,
8291            'tags': self.tags,
8292        }
@classmethod
def from_dict(cls, d)
8294    @classmethod
8295    def from_dict(cls, d):
8296        return cls(
8297            access_key=d.get('access_key'),
8298            bind_interface=d.get('bind_interface'),
8299            egress_filter=d.get('egress_filter'),
8300            endpoint=d.get('endpoint'),
8301            healthy=d.get('healthy'),
8302            id=d.get('id'),
8303            name=d.get('name'),
8304            port=d.get('port'),
8305            port_override=d.get('port_override'),
8306            region=d.get('region'),
8307            role_arn=d.get('role_arn'),
8308            role_external_id=d.get('role_external_id'),
8309            secret_access_key=d.get('secret_access_key'),
8310            secret_store_id=d.get('secret_store_id'),
8311            tags=d.get('tags'),
8312        )
class NodeCreateResponse:
8315class NodeCreateResponse:
8316    '''
8317         NodeCreateResponse reports how the Nodes were created in the system.
8318    '''
8319    __slots__ = [
8320        'meta',
8321        'node',
8322        'rate_limit',
8323        'token',
8324    ]
8325
8326    def __init__(
8327        self,
8328        meta=None,
8329        node=None,
8330        rate_limit=None,
8331        token=None,
8332    ):
8333        self.meta = meta if meta is not None else None
8334        '''
8335         Reserved for future use.
8336        '''
8337        self.node = node if node is not None else None
8338        '''
8339         The created Node.
8340        '''
8341        self.rate_limit = rate_limit if rate_limit is not None else None
8342        '''
8343         Rate limit information.
8344        '''
8345        self.token = token if token is not None else ''
8346        '''
8347         The auth token generated for the Node. The Node will use this token to
8348         authenticate with the strongDM API.
8349        '''
8350
8351    def __repr__(self):
8352        return '<sdm.NodeCreateResponse ' + \
8353            'meta: ' + repr(self.meta) + ' ' +\
8354            'node: ' + repr(self.node) + ' ' +\
8355            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8356            'token: ' + repr(self.token) + ' ' +\
8357            '>'
8358
8359    def to_dict(self):
8360        return {
8361            'meta': self.meta,
8362            'node': self.node,
8363            'rate_limit': self.rate_limit,
8364            'token': self.token,
8365        }
8366
8367    @classmethod
8368    def from_dict(cls, d):
8369        return cls(
8370            meta=d.get('meta'),
8371            node=d.get('node'),
8372            rate_limit=d.get('rate_limit'),
8373            token=d.get('token'),
8374        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8326    def __init__(
8327        self,
8328        meta=None,
8329        node=None,
8330        rate_limit=None,
8331        token=None,
8332    ):
8333        self.meta = meta if meta is not None else None
8334        '''
8335         Reserved for future use.
8336        '''
8337        self.node = node if node is not None else None
8338        '''
8339         The created Node.
8340        '''
8341        self.rate_limit = rate_limit if rate_limit is not None else None
8342        '''
8343         Rate limit information.
8344        '''
8345        self.token = token if token is not None else ''
8346        '''
8347         The auth token generated for the Node. The Node will use this token to
8348         authenticate with the strongDM API.
8349        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8359    def to_dict(self):
8360        return {
8361            'meta': self.meta,
8362            'node': self.node,
8363            'rate_limit': self.rate_limit,
8364            'token': self.token,
8365        }
@classmethod
def from_dict(cls, d)
8367    @classmethod
8368    def from_dict(cls, d):
8369        return cls(
8370            meta=d.get('meta'),
8371            node=d.get('node'),
8372            rate_limit=d.get('rate_limit'),
8373            token=d.get('token'),
8374        )
class NodeDeleteResponse:
8377class NodeDeleteResponse:
8378    '''
8379         NodeDeleteResponse returns information about a Node that was deleted.
8380    '''
8381    __slots__ = [
8382        'meta',
8383        'rate_limit',
8384    ]
8385
8386    def __init__(
8387        self,
8388        meta=None,
8389        rate_limit=None,
8390    ):
8391        self.meta = meta if meta is not None else None
8392        '''
8393         Reserved for future use.
8394        '''
8395        self.rate_limit = rate_limit if rate_limit is not None else None
8396        '''
8397         Rate limit information.
8398        '''
8399
8400    def __repr__(self):
8401        return '<sdm.NodeDeleteResponse ' + \
8402            'meta: ' + repr(self.meta) + ' ' +\
8403            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8404            '>'
8405
8406    def to_dict(self):
8407        return {
8408            'meta': self.meta,
8409            'rate_limit': self.rate_limit,
8410        }
8411
8412    @classmethod
8413    def from_dict(cls, d):
8414        return cls(
8415            meta=d.get('meta'),
8416            rate_limit=d.get('rate_limit'),
8417        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8386    def __init__(
8387        self,
8388        meta=None,
8389        rate_limit=None,
8390    ):
8391        self.meta = meta if meta is not None else None
8392        '''
8393         Reserved for future use.
8394        '''
8395        self.rate_limit = rate_limit if rate_limit is not None else None
8396        '''
8397         Rate limit information.
8398        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8406    def to_dict(self):
8407        return {
8408            'meta': self.meta,
8409            'rate_limit': self.rate_limit,
8410        }
@classmethod
def from_dict(cls, d)
8412    @classmethod
8413    def from_dict(cls, d):
8414        return cls(
8415            meta=d.get('meta'),
8416            rate_limit=d.get('rate_limit'),
8417        )
class NodeGetResponse:
8420class NodeGetResponse:
8421    '''
8422         NodeGetResponse returns a requested Node.
8423    '''
8424    __slots__ = [
8425        'meta',
8426        'node',
8427        'rate_limit',
8428    ]
8429
8430    def __init__(
8431        self,
8432        meta=None,
8433        node=None,
8434        rate_limit=None,
8435    ):
8436        self.meta = meta if meta is not None else None
8437        '''
8438         Reserved for future use.
8439        '''
8440        self.node = node if node is not None else None
8441        '''
8442         The requested Node.
8443        '''
8444        self.rate_limit = rate_limit if rate_limit is not None else None
8445        '''
8446         Rate limit information.
8447        '''
8448
8449    def __repr__(self):
8450        return '<sdm.NodeGetResponse ' + \
8451            'meta: ' + repr(self.meta) + ' ' +\
8452            'node: ' + repr(self.node) + ' ' +\
8453            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8454            '>'
8455
8456    def to_dict(self):
8457        return {
8458            'meta': self.meta,
8459            'node': self.node,
8460            'rate_limit': self.rate_limit,
8461        }
8462
8463    @classmethod
8464    def from_dict(cls, d):
8465        return cls(
8466            meta=d.get('meta'),
8467            node=d.get('node'),
8468            rate_limit=d.get('rate_limit'),
8469        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8430    def __init__(
8431        self,
8432        meta=None,
8433        node=None,
8434        rate_limit=None,
8435    ):
8436        self.meta = meta if meta is not None else None
8437        '''
8438         Reserved for future use.
8439        '''
8440        self.node = node if node is not None else None
8441        '''
8442         The requested Node.
8443        '''
8444        self.rate_limit = rate_limit if rate_limit is not None else None
8445        '''
8446         Rate limit information.
8447        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8456    def to_dict(self):
8457        return {
8458            'meta': self.meta,
8459            'node': self.node,
8460            'rate_limit': self.rate_limit,
8461        }
@classmethod
def from_dict(cls, d)
8463    @classmethod
8464    def from_dict(cls, d):
8465        return cls(
8466            meta=d.get('meta'),
8467            node=d.get('node'),
8468            rate_limit=d.get('rate_limit'),
8469        )
class NodeUpdateResponse:
8472class NodeUpdateResponse:
8473    '''
8474         NodeUpdateResponse returns the fields of a Node after it has been updated by
8475     a NodeUpdateRequest.
8476    '''
8477    __slots__ = [
8478        'meta',
8479        'node',
8480        'rate_limit',
8481    ]
8482
8483    def __init__(
8484        self,
8485        meta=None,
8486        node=None,
8487        rate_limit=None,
8488    ):
8489        self.meta = meta if meta is not None else None
8490        '''
8491         Reserved for future use.
8492        '''
8493        self.node = node if node is not None else None
8494        '''
8495         The updated Node.
8496        '''
8497        self.rate_limit = rate_limit if rate_limit is not None else None
8498        '''
8499         Rate limit information.
8500        '''
8501
8502    def __repr__(self):
8503        return '<sdm.NodeUpdateResponse ' + \
8504            'meta: ' + repr(self.meta) + ' ' +\
8505            'node: ' + repr(self.node) + ' ' +\
8506            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8507            '>'
8508
8509    def to_dict(self):
8510        return {
8511            'meta': self.meta,
8512            'node': self.node,
8513            'rate_limit': self.rate_limit,
8514        }
8515
8516    @classmethod
8517    def from_dict(cls, d):
8518        return cls(
8519            meta=d.get('meta'),
8520            node=d.get('node'),
8521            rate_limit=d.get('rate_limit'),
8522        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8483    def __init__(
8484        self,
8485        meta=None,
8486        node=None,
8487        rate_limit=None,
8488    ):
8489        self.meta = meta if meta is not None else None
8490        '''
8491         Reserved for future use.
8492        '''
8493        self.node = node if node is not None else None
8494        '''
8495         The updated Node.
8496        '''
8497        self.rate_limit = rate_limit if rate_limit is not None else None
8498        '''
8499         Rate limit information.
8500        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8509    def to_dict(self):
8510        return {
8511            'meta': self.meta,
8512            'node': self.node,
8513            'rate_limit': self.rate_limit,
8514        }
@classmethod
def from_dict(cls, d)
8516    @classmethod
8517    def from_dict(cls, d):
8518        return cls(
8519            meta=d.get('meta'),
8520            node=d.get('node'),
8521            rate_limit=d.get('rate_limit'),
8522        )
class Oracle:
8525class Oracle:
8526    __slots__ = [
8527        'bind_interface',
8528        'database',
8529        'egress_filter',
8530        'healthy',
8531        'hostname',
8532        'id',
8533        'name',
8534        'password',
8535        'port',
8536        'port_override',
8537        'secret_store_id',
8538        'tags',
8539        'tls_required',
8540        'username',
8541    ]
8542
8543    def __init__(
8544        self,
8545        bind_interface=None,
8546        database=None,
8547        egress_filter=None,
8548        healthy=None,
8549        hostname=None,
8550        id=None,
8551        name=None,
8552        password=None,
8553        port=None,
8554        port_override=None,
8555        secret_store_id=None,
8556        tags=None,
8557        tls_required=None,
8558        username=None,
8559    ):
8560        self.bind_interface = bind_interface if bind_interface is not None else ''
8561        '''
8562         Bind interface
8563        '''
8564        self.database = database if database is not None else ''
8565        self.egress_filter = egress_filter if egress_filter is not None else ''
8566        '''
8567         A filter applied to the routing logic to pin datasource to nodes.
8568        '''
8569        self.healthy = healthy if healthy is not None else False
8570        '''
8571         True if the datasource is reachable and the credentials are valid.
8572        '''
8573        self.hostname = hostname if hostname is not None else ''
8574        self.id = id if id is not None else ''
8575        '''
8576         Unique identifier of the Resource.
8577        '''
8578        self.name = name if name is not None else ''
8579        '''
8580         Unique human-readable name of the Resource.
8581        '''
8582        self.password = password if password is not None else ''
8583        self.port = port if port is not None else 0
8584        self.port_override = port_override if port_override is not None else 0
8585        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8586        '''
8587         ID of the secret store containing credentials for this resource, if any.
8588        '''
8589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8590        '''
8591         Tags is a map of key, value pairs.
8592        '''
8593        self.tls_required = tls_required if tls_required is not None else False
8594        self.username = username if username is not None else ''
8595
8596    def __repr__(self):
8597        return '<sdm.Oracle ' + \
8598            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8599            'database: ' + repr(self.database) + ' ' +\
8600            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8601            'healthy: ' + repr(self.healthy) + ' ' +\
8602            'hostname: ' + repr(self.hostname) + ' ' +\
8603            'id: ' + repr(self.id) + ' ' +\
8604            'name: ' + repr(self.name) + ' ' +\
8605            'password: ' + repr(self.password) + ' ' +\
8606            'port: ' + repr(self.port) + ' ' +\
8607            'port_override: ' + repr(self.port_override) + ' ' +\
8608            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8609            'tags: ' + repr(self.tags) + ' ' +\
8610            'tls_required: ' + repr(self.tls_required) + ' ' +\
8611            'username: ' + repr(self.username) + ' ' +\
8612            '>'
8613
8614    def to_dict(self):
8615        return {
8616            'bind_interface': self.bind_interface,
8617            'database': self.database,
8618            'egress_filter': self.egress_filter,
8619            'healthy': self.healthy,
8620            'hostname': self.hostname,
8621            'id': self.id,
8622            'name': self.name,
8623            'password': self.password,
8624            'port': self.port,
8625            'port_override': self.port_override,
8626            'secret_store_id': self.secret_store_id,
8627            'tags': self.tags,
8628            'tls_required': self.tls_required,
8629            'username': self.username,
8630        }
8631
8632    @classmethod
8633    def from_dict(cls, d):
8634        return cls(
8635            bind_interface=d.get('bind_interface'),
8636            database=d.get('database'),
8637            egress_filter=d.get('egress_filter'),
8638            healthy=d.get('healthy'),
8639            hostname=d.get('hostname'),
8640            id=d.get('id'),
8641            name=d.get('name'),
8642            password=d.get('password'),
8643            port=d.get('port'),
8644            port_override=d.get('port_override'),
8645            secret_store_id=d.get('secret_store_id'),
8646            tags=d.get('tags'),
8647            tls_required=d.get('tls_required'),
8648            username=d.get('username'),
8649        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8543    def __init__(
8544        self,
8545        bind_interface=None,
8546        database=None,
8547        egress_filter=None,
8548        healthy=None,
8549        hostname=None,
8550        id=None,
8551        name=None,
8552        password=None,
8553        port=None,
8554        port_override=None,
8555        secret_store_id=None,
8556        tags=None,
8557        tls_required=None,
8558        username=None,
8559    ):
8560        self.bind_interface = bind_interface if bind_interface is not None else ''
8561        '''
8562         Bind interface
8563        '''
8564        self.database = database if database is not None else ''
8565        self.egress_filter = egress_filter if egress_filter is not None else ''
8566        '''
8567         A filter applied to the routing logic to pin datasource to nodes.
8568        '''
8569        self.healthy = healthy if healthy is not None else False
8570        '''
8571         True if the datasource is reachable and the credentials are valid.
8572        '''
8573        self.hostname = hostname if hostname is not None else ''
8574        self.id = id if id is not None else ''
8575        '''
8576         Unique identifier of the Resource.
8577        '''
8578        self.name = name if name is not None else ''
8579        '''
8580         Unique human-readable name of the Resource.
8581        '''
8582        self.password = password if password is not None else ''
8583        self.port = port if port is not None else 0
8584        self.port_override = port_override if port_override is not None else 0
8585        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8586        '''
8587         ID of the secret store containing credentials for this resource, if any.
8588        '''
8589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8590        '''
8591         Tags is a map of key, value pairs.
8592        '''
8593        self.tls_required = tls_required if tls_required is not None else False
8594        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8614    def to_dict(self):
8615        return {
8616            'bind_interface': self.bind_interface,
8617            'database': self.database,
8618            'egress_filter': self.egress_filter,
8619            'healthy': self.healthy,
8620            'hostname': self.hostname,
8621            'id': self.id,
8622            'name': self.name,
8623            'password': self.password,
8624            'port': self.port,
8625            'port_override': self.port_override,
8626            'secret_store_id': self.secret_store_id,
8627            'tags': self.tags,
8628            'tls_required': self.tls_required,
8629            'username': self.username,
8630        }
@classmethod
def from_dict(cls, d)
8632    @classmethod
8633    def from_dict(cls, d):
8634        return cls(
8635            bind_interface=d.get('bind_interface'),
8636            database=d.get('database'),
8637            egress_filter=d.get('egress_filter'),
8638            healthy=d.get('healthy'),
8639            hostname=d.get('hostname'),
8640            id=d.get('id'),
8641            name=d.get('name'),
8642            password=d.get('password'),
8643            port=d.get('port'),
8644            port_override=d.get('port_override'),
8645            secret_store_id=d.get('secret_store_id'),
8646            tags=d.get('tags'),
8647            tls_required=d.get('tls_required'),
8648            username=d.get('username'),
8649        )
class Postgres:
8652class Postgres:
8653    __slots__ = [
8654        'bind_interface',
8655        'database',
8656        'egress_filter',
8657        'healthy',
8658        'hostname',
8659        'id',
8660        'name',
8661        'override_database',
8662        'password',
8663        'port',
8664        'port_override',
8665        'secret_store_id',
8666        'tags',
8667        'username',
8668    ]
8669
8670    def __init__(
8671        self,
8672        bind_interface=None,
8673        database=None,
8674        egress_filter=None,
8675        healthy=None,
8676        hostname=None,
8677        id=None,
8678        name=None,
8679        override_database=None,
8680        password=None,
8681        port=None,
8682        port_override=None,
8683        secret_store_id=None,
8684        tags=None,
8685        username=None,
8686    ):
8687        self.bind_interface = bind_interface if bind_interface is not None else ''
8688        '''
8689         Bind interface
8690        '''
8691        self.database = database if database is not None else ''
8692        self.egress_filter = egress_filter if egress_filter is not None else ''
8693        '''
8694         A filter applied to the routing logic to pin datasource to nodes.
8695        '''
8696        self.healthy = healthy if healthy is not None else False
8697        '''
8698         True if the datasource is reachable and the credentials are valid.
8699        '''
8700        self.hostname = hostname if hostname is not None else ''
8701        self.id = id if id is not None else ''
8702        '''
8703         Unique identifier of the Resource.
8704        '''
8705        self.name = name if name is not None else ''
8706        '''
8707         Unique human-readable name of the Resource.
8708        '''
8709        self.override_database = override_database if override_database is not None else False
8710        self.password = password if password is not None else ''
8711        self.port = port if port is not None else 0
8712        self.port_override = port_override if port_override is not None else 0
8713        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8714        '''
8715         ID of the secret store containing credentials for this resource, if any.
8716        '''
8717        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8718        '''
8719         Tags is a map of key, value pairs.
8720        '''
8721        self.username = username if username is not None else ''
8722
8723    def __repr__(self):
8724        return '<sdm.Postgres ' + \
8725            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8726            'database: ' + repr(self.database) + ' ' +\
8727            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8728            'healthy: ' + repr(self.healthy) + ' ' +\
8729            'hostname: ' + repr(self.hostname) + ' ' +\
8730            'id: ' + repr(self.id) + ' ' +\
8731            'name: ' + repr(self.name) + ' ' +\
8732            'override_database: ' + repr(self.override_database) + ' ' +\
8733            'password: ' + repr(self.password) + ' ' +\
8734            'port: ' + repr(self.port) + ' ' +\
8735            'port_override: ' + repr(self.port_override) + ' ' +\
8736            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8737            'tags: ' + repr(self.tags) + ' ' +\
8738            'username: ' + repr(self.username) + ' ' +\
8739            '>'
8740
8741    def to_dict(self):
8742        return {
8743            'bind_interface': self.bind_interface,
8744            'database': self.database,
8745            'egress_filter': self.egress_filter,
8746            'healthy': self.healthy,
8747            'hostname': self.hostname,
8748            'id': self.id,
8749            'name': self.name,
8750            'override_database': self.override_database,
8751            'password': self.password,
8752            'port': self.port,
8753            'port_override': self.port_override,
8754            'secret_store_id': self.secret_store_id,
8755            'tags': self.tags,
8756            'username': self.username,
8757        }
8758
8759    @classmethod
8760    def from_dict(cls, d):
8761        return cls(
8762            bind_interface=d.get('bind_interface'),
8763            database=d.get('database'),
8764            egress_filter=d.get('egress_filter'),
8765            healthy=d.get('healthy'),
8766            hostname=d.get('hostname'),
8767            id=d.get('id'),
8768            name=d.get('name'),
8769            override_database=d.get('override_database'),
8770            password=d.get('password'),
8771            port=d.get('port'),
8772            port_override=d.get('port_override'),
8773            secret_store_id=d.get('secret_store_id'),
8774            tags=d.get('tags'),
8775            username=d.get('username'),
8776        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8670    def __init__(
8671        self,
8672        bind_interface=None,
8673        database=None,
8674        egress_filter=None,
8675        healthy=None,
8676        hostname=None,
8677        id=None,
8678        name=None,
8679        override_database=None,
8680        password=None,
8681        port=None,
8682        port_override=None,
8683        secret_store_id=None,
8684        tags=None,
8685        username=None,
8686    ):
8687        self.bind_interface = bind_interface if bind_interface is not None else ''
8688        '''
8689         Bind interface
8690        '''
8691        self.database = database if database is not None else ''
8692        self.egress_filter = egress_filter if egress_filter is not None else ''
8693        '''
8694         A filter applied to the routing logic to pin datasource to nodes.
8695        '''
8696        self.healthy = healthy if healthy is not None else False
8697        '''
8698         True if the datasource is reachable and the credentials are valid.
8699        '''
8700        self.hostname = hostname if hostname is not None else ''
8701        self.id = id if id is not None else ''
8702        '''
8703         Unique identifier of the Resource.
8704        '''
8705        self.name = name if name is not None else ''
8706        '''
8707         Unique human-readable name of the Resource.
8708        '''
8709        self.override_database = override_database if override_database is not None else False
8710        self.password = password if password is not None else ''
8711        self.port = port if port is not None else 0
8712        self.port_override = port_override if port_override is not None else 0
8713        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8714        '''
8715         ID of the secret store containing credentials for this resource, if any.
8716        '''
8717        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8718        '''
8719         Tags is a map of key, value pairs.
8720        '''
8721        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8741    def to_dict(self):
8742        return {
8743            'bind_interface': self.bind_interface,
8744            'database': self.database,
8745            'egress_filter': self.egress_filter,
8746            'healthy': self.healthy,
8747            'hostname': self.hostname,
8748            'id': self.id,
8749            'name': self.name,
8750            'override_database': self.override_database,
8751            'password': self.password,
8752            'port': self.port,
8753            'port_override': self.port_override,
8754            'secret_store_id': self.secret_store_id,
8755            'tags': self.tags,
8756            'username': self.username,
8757        }
@classmethod
def from_dict(cls, d)
8759    @classmethod
8760    def from_dict(cls, d):
8761        return cls(
8762            bind_interface=d.get('bind_interface'),
8763            database=d.get('database'),
8764            egress_filter=d.get('egress_filter'),
8765            healthy=d.get('healthy'),
8766            hostname=d.get('hostname'),
8767            id=d.get('id'),
8768            name=d.get('name'),
8769            override_database=d.get('override_database'),
8770            password=d.get('password'),
8771            port=d.get('port'),
8772            port_override=d.get('port_override'),
8773            secret_store_id=d.get('secret_store_id'),
8774            tags=d.get('tags'),
8775            username=d.get('username'),
8776        )
class Presto:
8779class Presto:
8780    __slots__ = [
8781        'bind_interface',
8782        'database',
8783        'egress_filter',
8784        'healthy',
8785        'hostname',
8786        'id',
8787        'name',
8788        'password',
8789        'port',
8790        'port_override',
8791        'secret_store_id',
8792        'tags',
8793        'tls_required',
8794        'username',
8795    ]
8796
8797    def __init__(
8798        self,
8799        bind_interface=None,
8800        database=None,
8801        egress_filter=None,
8802        healthy=None,
8803        hostname=None,
8804        id=None,
8805        name=None,
8806        password=None,
8807        port=None,
8808        port_override=None,
8809        secret_store_id=None,
8810        tags=None,
8811        tls_required=None,
8812        username=None,
8813    ):
8814        self.bind_interface = bind_interface if bind_interface is not None else ''
8815        '''
8816         Bind interface
8817        '''
8818        self.database = database if database is not None else ''
8819        self.egress_filter = egress_filter if egress_filter is not None else ''
8820        '''
8821         A filter applied to the routing logic to pin datasource to nodes.
8822        '''
8823        self.healthy = healthy if healthy is not None else False
8824        '''
8825         True if the datasource is reachable and the credentials are valid.
8826        '''
8827        self.hostname = hostname if hostname is not None else ''
8828        self.id = id if id is not None else ''
8829        '''
8830         Unique identifier of the Resource.
8831        '''
8832        self.name = name if name is not None else ''
8833        '''
8834         Unique human-readable name of the Resource.
8835        '''
8836        self.password = password if password is not None else ''
8837        self.port = port if port is not None else 0
8838        self.port_override = port_override if port_override is not None else 0
8839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8840        '''
8841         ID of the secret store containing credentials for this resource, if any.
8842        '''
8843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8844        '''
8845         Tags is a map of key, value pairs.
8846        '''
8847        self.tls_required = tls_required if tls_required is not None else False
8848        self.username = username if username is not None else ''
8849
8850    def __repr__(self):
8851        return '<sdm.Presto ' + \
8852            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8853            'database: ' + repr(self.database) + ' ' +\
8854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8855            'healthy: ' + repr(self.healthy) + ' ' +\
8856            'hostname: ' + repr(self.hostname) + ' ' +\
8857            'id: ' + repr(self.id) + ' ' +\
8858            'name: ' + repr(self.name) + ' ' +\
8859            'password: ' + repr(self.password) + ' ' +\
8860            'port: ' + repr(self.port) + ' ' +\
8861            'port_override: ' + repr(self.port_override) + ' ' +\
8862            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8863            'tags: ' + repr(self.tags) + ' ' +\
8864            'tls_required: ' + repr(self.tls_required) + ' ' +\
8865            'username: ' + repr(self.username) + ' ' +\
8866            '>'
8867
8868    def to_dict(self):
8869        return {
8870            'bind_interface': self.bind_interface,
8871            'database': self.database,
8872            'egress_filter': self.egress_filter,
8873            'healthy': self.healthy,
8874            'hostname': self.hostname,
8875            'id': self.id,
8876            'name': self.name,
8877            'password': self.password,
8878            'port': self.port,
8879            'port_override': self.port_override,
8880            'secret_store_id': self.secret_store_id,
8881            'tags': self.tags,
8882            'tls_required': self.tls_required,
8883            'username': self.username,
8884        }
8885
8886    @classmethod
8887    def from_dict(cls, d):
8888        return cls(
8889            bind_interface=d.get('bind_interface'),
8890            database=d.get('database'),
8891            egress_filter=d.get('egress_filter'),
8892            healthy=d.get('healthy'),
8893            hostname=d.get('hostname'),
8894            id=d.get('id'),
8895            name=d.get('name'),
8896            password=d.get('password'),
8897            port=d.get('port'),
8898            port_override=d.get('port_override'),
8899            secret_store_id=d.get('secret_store_id'),
8900            tags=d.get('tags'),
8901            tls_required=d.get('tls_required'),
8902            username=d.get('username'),
8903        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8797    def __init__(
8798        self,
8799        bind_interface=None,
8800        database=None,
8801        egress_filter=None,
8802        healthy=None,
8803        hostname=None,
8804        id=None,
8805        name=None,
8806        password=None,
8807        port=None,
8808        port_override=None,
8809        secret_store_id=None,
8810        tags=None,
8811        tls_required=None,
8812        username=None,
8813    ):
8814        self.bind_interface = bind_interface if bind_interface is not None else ''
8815        '''
8816         Bind interface
8817        '''
8818        self.database = database if database is not None else ''
8819        self.egress_filter = egress_filter if egress_filter is not None else ''
8820        '''
8821         A filter applied to the routing logic to pin datasource to nodes.
8822        '''
8823        self.healthy = healthy if healthy is not None else False
8824        '''
8825         True if the datasource is reachable and the credentials are valid.
8826        '''
8827        self.hostname = hostname if hostname is not None else ''
8828        self.id = id if id is not None else ''
8829        '''
8830         Unique identifier of the Resource.
8831        '''
8832        self.name = name if name is not None else ''
8833        '''
8834         Unique human-readable name of the Resource.
8835        '''
8836        self.password = password if password is not None else ''
8837        self.port = port if port is not None else 0
8838        self.port_override = port_override if port_override is not None else 0
8839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8840        '''
8841         ID of the secret store containing credentials for this resource, if any.
8842        '''
8843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8844        '''
8845         Tags is a map of key, value pairs.
8846        '''
8847        self.tls_required = tls_required if tls_required is not None else False
8848        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8868    def to_dict(self):
8869        return {
8870            'bind_interface': self.bind_interface,
8871            'database': self.database,
8872            'egress_filter': self.egress_filter,
8873            'healthy': self.healthy,
8874            'hostname': self.hostname,
8875            'id': self.id,
8876            'name': self.name,
8877            'password': self.password,
8878            'port': self.port,
8879            'port_override': self.port_override,
8880            'secret_store_id': self.secret_store_id,
8881            'tags': self.tags,
8882            'tls_required': self.tls_required,
8883            'username': self.username,
8884        }
@classmethod
def from_dict(cls, d)
8886    @classmethod
8887    def from_dict(cls, d):
8888        return cls(
8889            bind_interface=d.get('bind_interface'),
8890            database=d.get('database'),
8891            egress_filter=d.get('egress_filter'),
8892            healthy=d.get('healthy'),
8893            hostname=d.get('hostname'),
8894            id=d.get('id'),
8895            name=d.get('name'),
8896            password=d.get('password'),
8897            port=d.get('port'),
8898            port_override=d.get('port_override'),
8899            secret_store_id=d.get('secret_store_id'),
8900            tags=d.get('tags'),
8901            tls_required=d.get('tls_required'),
8902            username=d.get('username'),
8903        )
class RDP:
8906class RDP:
8907    __slots__ = [
8908        'bind_interface',
8909        'downgrade_nla_connections',
8910        'egress_filter',
8911        'healthy',
8912        'hostname',
8913        'id',
8914        'name',
8915        'password',
8916        'port',
8917        'port_override',
8918        'secret_store_id',
8919        'tags',
8920        'username',
8921    ]
8922
8923    def __init__(
8924        self,
8925        bind_interface=None,
8926        downgrade_nla_connections=None,
8927        egress_filter=None,
8928        healthy=None,
8929        hostname=None,
8930        id=None,
8931        name=None,
8932        password=None,
8933        port=None,
8934        port_override=None,
8935        secret_store_id=None,
8936        tags=None,
8937        username=None,
8938    ):
8939        self.bind_interface = bind_interface if bind_interface is not None else ''
8940        '''
8941         Bind interface
8942        '''
8943        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8944        self.egress_filter = egress_filter if egress_filter is not None else ''
8945        '''
8946         A filter applied to the routing logic to pin datasource to nodes.
8947        '''
8948        self.healthy = healthy if healthy is not None else False
8949        '''
8950         True if the datasource is reachable and the credentials are valid.
8951        '''
8952        self.hostname = hostname if hostname is not None else ''
8953        self.id = id if id is not None else ''
8954        '''
8955         Unique identifier of the Resource.
8956        '''
8957        self.name = name if name is not None else ''
8958        '''
8959         Unique human-readable name of the Resource.
8960        '''
8961        self.password = password if password is not None else ''
8962        self.port = port if port is not None else 0
8963        self.port_override = port_override if port_override is not None else 0
8964        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8965        '''
8966         ID of the secret store containing credentials for this resource, if any.
8967        '''
8968        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8969        '''
8970         Tags is a map of key, value pairs.
8971        '''
8972        self.username = username if username is not None else ''
8973
8974    def __repr__(self):
8975        return '<sdm.RDP ' + \
8976            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8977            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
8978            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8979            'healthy: ' + repr(self.healthy) + ' ' +\
8980            'hostname: ' + repr(self.hostname) + ' ' +\
8981            'id: ' + repr(self.id) + ' ' +\
8982            'name: ' + repr(self.name) + ' ' +\
8983            'password: ' + repr(self.password) + ' ' +\
8984            'port: ' + repr(self.port) + ' ' +\
8985            'port_override: ' + repr(self.port_override) + ' ' +\
8986            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8987            'tags: ' + repr(self.tags) + ' ' +\
8988            'username: ' + repr(self.username) + ' ' +\
8989            '>'
8990
8991    def to_dict(self):
8992        return {
8993            'bind_interface': self.bind_interface,
8994            'downgrade_nla_connections': self.downgrade_nla_connections,
8995            'egress_filter': self.egress_filter,
8996            'healthy': self.healthy,
8997            'hostname': self.hostname,
8998            'id': self.id,
8999            'name': self.name,
9000            'password': self.password,
9001            'port': self.port,
9002            'port_override': self.port_override,
9003            'secret_store_id': self.secret_store_id,
9004            'tags': self.tags,
9005            'username': self.username,
9006        }
9007
9008    @classmethod
9009    def from_dict(cls, d):
9010        return cls(
9011            bind_interface=d.get('bind_interface'),
9012            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9013            egress_filter=d.get('egress_filter'),
9014            healthy=d.get('healthy'),
9015            hostname=d.get('hostname'),
9016            id=d.get('id'),
9017            name=d.get('name'),
9018            password=d.get('password'),
9019            port=d.get('port'),
9020            port_override=d.get('port_override'),
9021            secret_store_id=d.get('secret_store_id'),
9022            tags=d.get('tags'),
9023            username=d.get('username'),
9024        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8923    def __init__(
8924        self,
8925        bind_interface=None,
8926        downgrade_nla_connections=None,
8927        egress_filter=None,
8928        healthy=None,
8929        hostname=None,
8930        id=None,
8931        name=None,
8932        password=None,
8933        port=None,
8934        port_override=None,
8935        secret_store_id=None,
8936        tags=None,
8937        username=None,
8938    ):
8939        self.bind_interface = bind_interface if bind_interface is not None else ''
8940        '''
8941         Bind interface
8942        '''
8943        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8944        self.egress_filter = egress_filter if egress_filter is not None else ''
8945        '''
8946         A filter applied to the routing logic to pin datasource to nodes.
8947        '''
8948        self.healthy = healthy if healthy is not None else False
8949        '''
8950         True if the datasource is reachable and the credentials are valid.
8951        '''
8952        self.hostname = hostname if hostname is not None else ''
8953        self.id = id if id is not None else ''
8954        '''
8955         Unique identifier of the Resource.
8956        '''
8957        self.name = name if name is not None else ''
8958        '''
8959         Unique human-readable name of the Resource.
8960        '''
8961        self.password = password if password is not None else ''
8962        self.port = port if port is not None else 0
8963        self.port_override = port_override if port_override is not None else 0
8964        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8965        '''
8966         ID of the secret store containing credentials for this resource, if any.
8967        '''
8968        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8969        '''
8970         Tags is a map of key, value pairs.
8971        '''
8972        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8991    def to_dict(self):
8992        return {
8993            'bind_interface': self.bind_interface,
8994            'downgrade_nla_connections': self.downgrade_nla_connections,
8995            'egress_filter': self.egress_filter,
8996            'healthy': self.healthy,
8997            'hostname': self.hostname,
8998            'id': self.id,
8999            'name': self.name,
9000            'password': self.password,
9001            'port': self.port,
9002            'port_override': self.port_override,
9003            'secret_store_id': self.secret_store_id,
9004            'tags': self.tags,
9005            'username': self.username,
9006        }
@classmethod
def from_dict(cls, d)
9008    @classmethod
9009    def from_dict(cls, d):
9010        return cls(
9011            bind_interface=d.get('bind_interface'),
9012            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9013            egress_filter=d.get('egress_filter'),
9014            healthy=d.get('healthy'),
9015            hostname=d.get('hostname'),
9016            id=d.get('id'),
9017            name=d.get('name'),
9018            password=d.get('password'),
9019            port=d.get('port'),
9020            port_override=d.get('port_override'),
9021            secret_store_id=d.get('secret_store_id'),
9022            tags=d.get('tags'),
9023            username=d.get('username'),
9024        )
class RabbitMQAMQP091:
9027class RabbitMQAMQP091:
9028    __slots__ = [
9029        'bind_interface',
9030        'egress_filter',
9031        'healthy',
9032        'hostname',
9033        'id',
9034        'name',
9035        'password',
9036        'port',
9037        'port_override',
9038        'secret_store_id',
9039        'tags',
9040        'tls_required',
9041        'username',
9042    ]
9043
9044    def __init__(
9045        self,
9046        bind_interface=None,
9047        egress_filter=None,
9048        healthy=None,
9049        hostname=None,
9050        id=None,
9051        name=None,
9052        password=None,
9053        port=None,
9054        port_override=None,
9055        secret_store_id=None,
9056        tags=None,
9057        tls_required=None,
9058        username=None,
9059    ):
9060        self.bind_interface = bind_interface if bind_interface is not None else ''
9061        '''
9062         Bind interface
9063        '''
9064        self.egress_filter = egress_filter if egress_filter is not None else ''
9065        '''
9066         A filter applied to the routing logic to pin datasource to nodes.
9067        '''
9068        self.healthy = healthy if healthy is not None else False
9069        '''
9070         True if the datasource is reachable and the credentials are valid.
9071        '''
9072        self.hostname = hostname if hostname is not None else ''
9073        self.id = id if id is not None else ''
9074        '''
9075         Unique identifier of the Resource.
9076        '''
9077        self.name = name if name is not None else ''
9078        '''
9079         Unique human-readable name of the Resource.
9080        '''
9081        self.password = password if password is not None else ''
9082        self.port = port if port is not None else 0
9083        self.port_override = port_override if port_override is not None else 0
9084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9085        '''
9086         ID of the secret store containing credentials for this resource, if any.
9087        '''
9088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9089        '''
9090         Tags is a map of key, value pairs.
9091        '''
9092        self.tls_required = tls_required if tls_required is not None else False
9093        self.username = username if username is not None else ''
9094
9095    def __repr__(self):
9096        return '<sdm.RabbitMQAMQP091 ' + \
9097            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9098            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9099            'healthy: ' + repr(self.healthy) + ' ' +\
9100            'hostname: ' + repr(self.hostname) + ' ' +\
9101            'id: ' + repr(self.id) + ' ' +\
9102            'name: ' + repr(self.name) + ' ' +\
9103            'password: ' + repr(self.password) + ' ' +\
9104            'port: ' + repr(self.port) + ' ' +\
9105            'port_override: ' + repr(self.port_override) + ' ' +\
9106            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9107            'tags: ' + repr(self.tags) + ' ' +\
9108            'tls_required: ' + repr(self.tls_required) + ' ' +\
9109            'username: ' + repr(self.username) + ' ' +\
9110            '>'
9111
9112    def to_dict(self):
9113        return {
9114            'bind_interface': self.bind_interface,
9115            'egress_filter': self.egress_filter,
9116            'healthy': self.healthy,
9117            'hostname': self.hostname,
9118            'id': self.id,
9119            'name': self.name,
9120            'password': self.password,
9121            'port': self.port,
9122            'port_override': self.port_override,
9123            'secret_store_id': self.secret_store_id,
9124            'tags': self.tags,
9125            'tls_required': self.tls_required,
9126            'username': self.username,
9127        }
9128
9129    @classmethod
9130    def from_dict(cls, d):
9131        return cls(
9132            bind_interface=d.get('bind_interface'),
9133            egress_filter=d.get('egress_filter'),
9134            healthy=d.get('healthy'),
9135            hostname=d.get('hostname'),
9136            id=d.get('id'),
9137            name=d.get('name'),
9138            password=d.get('password'),
9139            port=d.get('port'),
9140            port_override=d.get('port_override'),
9141            secret_store_id=d.get('secret_store_id'),
9142            tags=d.get('tags'),
9143            tls_required=d.get('tls_required'),
9144            username=d.get('username'),
9145        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9044    def __init__(
9045        self,
9046        bind_interface=None,
9047        egress_filter=None,
9048        healthy=None,
9049        hostname=None,
9050        id=None,
9051        name=None,
9052        password=None,
9053        port=None,
9054        port_override=None,
9055        secret_store_id=None,
9056        tags=None,
9057        tls_required=None,
9058        username=None,
9059    ):
9060        self.bind_interface = bind_interface if bind_interface is not None else ''
9061        '''
9062         Bind interface
9063        '''
9064        self.egress_filter = egress_filter if egress_filter is not None else ''
9065        '''
9066         A filter applied to the routing logic to pin datasource to nodes.
9067        '''
9068        self.healthy = healthy if healthy is not None else False
9069        '''
9070         True if the datasource is reachable and the credentials are valid.
9071        '''
9072        self.hostname = hostname if hostname is not None else ''
9073        self.id = id if id is not None else ''
9074        '''
9075         Unique identifier of the Resource.
9076        '''
9077        self.name = name if name is not None else ''
9078        '''
9079         Unique human-readable name of the Resource.
9080        '''
9081        self.password = password if password is not None else ''
9082        self.port = port if port is not None else 0
9083        self.port_override = port_override if port_override is not None else 0
9084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9085        '''
9086         ID of the secret store containing credentials for this resource, if any.
9087        '''
9088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9089        '''
9090         Tags is a map of key, value pairs.
9091        '''
9092        self.tls_required = tls_required if tls_required is not None else False
9093        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9112    def to_dict(self):
9113        return {
9114            'bind_interface': self.bind_interface,
9115            'egress_filter': self.egress_filter,
9116            'healthy': self.healthy,
9117            'hostname': self.hostname,
9118            'id': self.id,
9119            'name': self.name,
9120            'password': self.password,
9121            'port': self.port,
9122            'port_override': self.port_override,
9123            'secret_store_id': self.secret_store_id,
9124            'tags': self.tags,
9125            'tls_required': self.tls_required,
9126            'username': self.username,
9127        }
@classmethod
def from_dict(cls, d)
9129    @classmethod
9130    def from_dict(cls, d):
9131        return cls(
9132            bind_interface=d.get('bind_interface'),
9133            egress_filter=d.get('egress_filter'),
9134            healthy=d.get('healthy'),
9135            hostname=d.get('hostname'),
9136            id=d.get('id'),
9137            name=d.get('name'),
9138            password=d.get('password'),
9139            port=d.get('port'),
9140            port_override=d.get('port_override'),
9141            secret_store_id=d.get('secret_store_id'),
9142            tags=d.get('tags'),
9143            tls_required=d.get('tls_required'),
9144            username=d.get('username'),
9145        )
class RateLimitMetadata:
9148class RateLimitMetadata:
9149    '''
9150         RateLimitMetadata contains information about remaining requests avaialable
9151     to the user over some timeframe.
9152    '''
9153    __slots__ = [
9154        'bucket',
9155        'limit',
9156        'remaining',
9157        'reset_at',
9158    ]
9159
9160    def __init__(
9161        self,
9162        bucket=None,
9163        limit=None,
9164        remaining=None,
9165        reset_at=None,
9166    ):
9167        self.bucket = bucket if bucket is not None else ''
9168        '''
9169         The bucket this user/token is associated with, which may be shared between
9170         multiple users/tokens.
9171        '''
9172        self.limit = limit if limit is not None else 0
9173        '''
9174         How many total requests the user/token is authorized to make before being
9175         rate limited.
9176        '''
9177        self.remaining = remaining if remaining is not None else 0
9178        '''
9179         How many remaining requests out of the limit are still avaialable.
9180        '''
9181        self.reset_at = reset_at if reset_at is not None else None
9182        '''
9183         The time when remaining will be reset to limit.
9184        '''
9185
9186    def __repr__(self):
9187        return '<sdm.RateLimitMetadata ' + \
9188            'bucket: ' + repr(self.bucket) + ' ' +\
9189            'limit: ' + repr(self.limit) + ' ' +\
9190            'remaining: ' + repr(self.remaining) + ' ' +\
9191            'reset_at: ' + repr(self.reset_at) + ' ' +\
9192            '>'
9193
9194    def to_dict(self):
9195        return {
9196            'bucket': self.bucket,
9197            'limit': self.limit,
9198            'remaining': self.remaining,
9199            'reset_at': self.reset_at,
9200        }
9201
9202    @classmethod
9203    def from_dict(cls, d):
9204        return cls(
9205            bucket=d.get('bucket'),
9206            limit=d.get('limit'),
9207            remaining=d.get('remaining'),
9208            reset_at=d.get('reset_at'),
9209        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9160    def __init__(
9161        self,
9162        bucket=None,
9163        limit=None,
9164        remaining=None,
9165        reset_at=None,
9166    ):
9167        self.bucket = bucket if bucket is not None else ''
9168        '''
9169         The bucket this user/token is associated with, which may be shared between
9170         multiple users/tokens.
9171        '''
9172        self.limit = limit if limit is not None else 0
9173        '''
9174         How many total requests the user/token is authorized to make before being
9175         rate limited.
9176        '''
9177        self.remaining = remaining if remaining is not None else 0
9178        '''
9179         How many remaining requests out of the limit are still avaialable.
9180        '''
9181        self.reset_at = reset_at if reset_at is not None else None
9182        '''
9183         The time when remaining will be reset to limit.
9184        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9194    def to_dict(self):
9195        return {
9196            'bucket': self.bucket,
9197            'limit': self.limit,
9198            'remaining': self.remaining,
9199            'reset_at': self.reset_at,
9200        }
@classmethod
def from_dict(cls, d)
9202    @classmethod
9203    def from_dict(cls, d):
9204        return cls(
9205            bucket=d.get('bucket'),
9206            limit=d.get('limit'),
9207            remaining=d.get('remaining'),
9208            reset_at=d.get('reset_at'),
9209        )
class RawTCP:
9212class RawTCP:
9213    __slots__ = [
9214        'bind_interface',
9215        'egress_filter',
9216        'healthy',
9217        'hostname',
9218        'id',
9219        'name',
9220        'port',
9221        'port_override',
9222        'secret_store_id',
9223        'tags',
9224    ]
9225
9226    def __init__(
9227        self,
9228        bind_interface=None,
9229        egress_filter=None,
9230        healthy=None,
9231        hostname=None,
9232        id=None,
9233        name=None,
9234        port=None,
9235        port_override=None,
9236        secret_store_id=None,
9237        tags=None,
9238    ):
9239        self.bind_interface = bind_interface if bind_interface is not None else ''
9240        '''
9241         Bind interface
9242        '''
9243        self.egress_filter = egress_filter if egress_filter is not None else ''
9244        '''
9245         A filter applied to the routing logic to pin datasource to nodes.
9246        '''
9247        self.healthy = healthy if healthy is not None else False
9248        '''
9249         True if the datasource is reachable and the credentials are valid.
9250        '''
9251        self.hostname = hostname if hostname is not None else ''
9252        self.id = id if id is not None else ''
9253        '''
9254         Unique identifier of the Resource.
9255        '''
9256        self.name = name if name is not None else ''
9257        '''
9258         Unique human-readable name of the Resource.
9259        '''
9260        self.port = port if port is not None else 0
9261        self.port_override = port_override if port_override is not None else 0
9262        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9263        '''
9264         ID of the secret store containing credentials for this resource, if any.
9265        '''
9266        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9267        '''
9268         Tags is a map of key, value pairs.
9269        '''
9270
9271    def __repr__(self):
9272        return '<sdm.RawTCP ' + \
9273            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9274            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9275            'healthy: ' + repr(self.healthy) + ' ' +\
9276            'hostname: ' + repr(self.hostname) + ' ' +\
9277            'id: ' + repr(self.id) + ' ' +\
9278            'name: ' + repr(self.name) + ' ' +\
9279            'port: ' + repr(self.port) + ' ' +\
9280            'port_override: ' + repr(self.port_override) + ' ' +\
9281            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9282            'tags: ' + repr(self.tags) + ' ' +\
9283            '>'
9284
9285    def to_dict(self):
9286        return {
9287            'bind_interface': self.bind_interface,
9288            'egress_filter': self.egress_filter,
9289            'healthy': self.healthy,
9290            'hostname': self.hostname,
9291            'id': self.id,
9292            'name': self.name,
9293            'port': self.port,
9294            'port_override': self.port_override,
9295            'secret_store_id': self.secret_store_id,
9296            'tags': self.tags,
9297        }
9298
9299    @classmethod
9300    def from_dict(cls, d):
9301        return cls(
9302            bind_interface=d.get('bind_interface'),
9303            egress_filter=d.get('egress_filter'),
9304            healthy=d.get('healthy'),
9305            hostname=d.get('hostname'),
9306            id=d.get('id'),
9307            name=d.get('name'),
9308            port=d.get('port'),
9309            port_override=d.get('port_override'),
9310            secret_store_id=d.get('secret_store_id'),
9311            tags=d.get('tags'),
9312        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9226    def __init__(
9227        self,
9228        bind_interface=None,
9229        egress_filter=None,
9230        healthy=None,
9231        hostname=None,
9232        id=None,
9233        name=None,
9234        port=None,
9235        port_override=None,
9236        secret_store_id=None,
9237        tags=None,
9238    ):
9239        self.bind_interface = bind_interface if bind_interface is not None else ''
9240        '''
9241         Bind interface
9242        '''
9243        self.egress_filter = egress_filter if egress_filter is not None else ''
9244        '''
9245         A filter applied to the routing logic to pin datasource to nodes.
9246        '''
9247        self.healthy = healthy if healthy is not None else False
9248        '''
9249         True if the datasource is reachable and the credentials are valid.
9250        '''
9251        self.hostname = hostname if hostname is not None else ''
9252        self.id = id if id is not None else ''
9253        '''
9254         Unique identifier of the Resource.
9255        '''
9256        self.name = name if name is not None else ''
9257        '''
9258         Unique human-readable name of the Resource.
9259        '''
9260        self.port = port if port is not None else 0
9261        self.port_override = port_override if port_override is not None else 0
9262        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9263        '''
9264         ID of the secret store containing credentials for this resource, if any.
9265        '''
9266        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9267        '''
9268         Tags is a map of key, value pairs.
9269        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9285    def to_dict(self):
9286        return {
9287            'bind_interface': self.bind_interface,
9288            'egress_filter': self.egress_filter,
9289            'healthy': self.healthy,
9290            'hostname': self.hostname,
9291            'id': self.id,
9292            'name': self.name,
9293            'port': self.port,
9294            'port_override': self.port_override,
9295            'secret_store_id': self.secret_store_id,
9296            'tags': self.tags,
9297        }
@classmethod
def from_dict(cls, d)
9299    @classmethod
9300    def from_dict(cls, d):
9301        return cls(
9302            bind_interface=d.get('bind_interface'),
9303            egress_filter=d.get('egress_filter'),
9304            healthy=d.get('healthy'),
9305            hostname=d.get('hostname'),
9306            id=d.get('id'),
9307            name=d.get('name'),
9308            port=d.get('port'),
9309            port_override=d.get('port_override'),
9310            secret_store_id=d.get('secret_store_id'),
9311            tags=d.get('tags'),
9312        )
class Redis:
9315class Redis:
9316    __slots__ = [
9317        'bind_interface',
9318        'egress_filter',
9319        'healthy',
9320        'hostname',
9321        'id',
9322        'name',
9323        'password',
9324        'port',
9325        'port_override',
9326        'secret_store_id',
9327        'tags',
9328    ]
9329
9330    def __init__(
9331        self,
9332        bind_interface=None,
9333        egress_filter=None,
9334        healthy=None,
9335        hostname=None,
9336        id=None,
9337        name=None,
9338        password=None,
9339        port=None,
9340        port_override=None,
9341        secret_store_id=None,
9342        tags=None,
9343    ):
9344        self.bind_interface = bind_interface if bind_interface is not None else ''
9345        '''
9346         Bind interface
9347        '''
9348        self.egress_filter = egress_filter if egress_filter is not None else ''
9349        '''
9350         A filter applied to the routing logic to pin datasource to nodes.
9351        '''
9352        self.healthy = healthy if healthy is not None else False
9353        '''
9354         True if the datasource is reachable and the credentials are valid.
9355        '''
9356        self.hostname = hostname if hostname is not None else ''
9357        self.id = id if id is not None else ''
9358        '''
9359         Unique identifier of the Resource.
9360        '''
9361        self.name = name if name is not None else ''
9362        '''
9363         Unique human-readable name of the Resource.
9364        '''
9365        self.password = password if password is not None else ''
9366        self.port = port if port is not None else 0
9367        self.port_override = port_override if port_override is not None else 0
9368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9369        '''
9370         ID of the secret store containing credentials for this resource, if any.
9371        '''
9372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9373        '''
9374         Tags is a map of key, value pairs.
9375        '''
9376
9377    def __repr__(self):
9378        return '<sdm.Redis ' + \
9379            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9380            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9381            'healthy: ' + repr(self.healthy) + ' ' +\
9382            'hostname: ' + repr(self.hostname) + ' ' +\
9383            'id: ' + repr(self.id) + ' ' +\
9384            'name: ' + repr(self.name) + ' ' +\
9385            'password: ' + repr(self.password) + ' ' +\
9386            'port: ' + repr(self.port) + ' ' +\
9387            'port_override: ' + repr(self.port_override) + ' ' +\
9388            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9389            'tags: ' + repr(self.tags) + ' ' +\
9390            '>'
9391
9392    def to_dict(self):
9393        return {
9394            'bind_interface': self.bind_interface,
9395            'egress_filter': self.egress_filter,
9396            'healthy': self.healthy,
9397            'hostname': self.hostname,
9398            'id': self.id,
9399            'name': self.name,
9400            'password': self.password,
9401            'port': self.port,
9402            'port_override': self.port_override,
9403            'secret_store_id': self.secret_store_id,
9404            'tags': self.tags,
9405        }
9406
9407    @classmethod
9408    def from_dict(cls, d):
9409        return cls(
9410            bind_interface=d.get('bind_interface'),
9411            egress_filter=d.get('egress_filter'),
9412            healthy=d.get('healthy'),
9413            hostname=d.get('hostname'),
9414            id=d.get('id'),
9415            name=d.get('name'),
9416            password=d.get('password'),
9417            port=d.get('port'),
9418            port_override=d.get('port_override'),
9419            secret_store_id=d.get('secret_store_id'),
9420            tags=d.get('tags'),
9421        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
9330    def __init__(
9331        self,
9332        bind_interface=None,
9333        egress_filter=None,
9334        healthy=None,
9335        hostname=None,
9336        id=None,
9337        name=None,
9338        password=None,
9339        port=None,
9340        port_override=None,
9341        secret_store_id=None,
9342        tags=None,
9343    ):
9344        self.bind_interface = bind_interface if bind_interface is not None else ''
9345        '''
9346         Bind interface
9347        '''
9348        self.egress_filter = egress_filter if egress_filter is not None else ''
9349        '''
9350         A filter applied to the routing logic to pin datasource to nodes.
9351        '''
9352        self.healthy = healthy if healthy is not None else False
9353        '''
9354         True if the datasource is reachable and the credentials are valid.
9355        '''
9356        self.hostname = hostname if hostname is not None else ''
9357        self.id = id if id is not None else ''
9358        '''
9359         Unique identifier of the Resource.
9360        '''
9361        self.name = name if name is not None else ''
9362        '''
9363         Unique human-readable name of the Resource.
9364        '''
9365        self.password = password if password is not None else ''
9366        self.port = port if port is not None else 0
9367        self.port_override = port_override if port_override is not None else 0
9368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9369        '''
9370         ID of the secret store containing credentials for this resource, if any.
9371        '''
9372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9373        '''
9374         Tags is a map of key, value pairs.
9375        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9392    def to_dict(self):
9393        return {
9394            'bind_interface': self.bind_interface,
9395            'egress_filter': self.egress_filter,
9396            'healthy': self.healthy,
9397            'hostname': self.hostname,
9398            'id': self.id,
9399            'name': self.name,
9400            'password': self.password,
9401            'port': self.port,
9402            'port_override': self.port_override,
9403            'secret_store_id': self.secret_store_id,
9404            'tags': self.tags,
9405        }
@classmethod
def from_dict(cls, d)
9407    @classmethod
9408    def from_dict(cls, d):
9409        return cls(
9410            bind_interface=d.get('bind_interface'),
9411            egress_filter=d.get('egress_filter'),
9412            healthy=d.get('healthy'),
9413            hostname=d.get('hostname'),
9414            id=d.get('id'),
9415            name=d.get('name'),
9416            password=d.get('password'),
9417            port=d.get('port'),
9418            port_override=d.get('port_override'),
9419            secret_store_id=d.get('secret_store_id'),
9420            tags=d.get('tags'),
9421        )
class Redshift:
9424class Redshift:
9425    __slots__ = [
9426        'bind_interface',
9427        'database',
9428        'egress_filter',
9429        'healthy',
9430        'hostname',
9431        'id',
9432        'name',
9433        'override_database',
9434        'password',
9435        'port',
9436        'port_override',
9437        'secret_store_id',
9438        'tags',
9439        'username',
9440    ]
9441
9442    def __init__(
9443        self,
9444        bind_interface=None,
9445        database=None,
9446        egress_filter=None,
9447        healthy=None,
9448        hostname=None,
9449        id=None,
9450        name=None,
9451        override_database=None,
9452        password=None,
9453        port=None,
9454        port_override=None,
9455        secret_store_id=None,
9456        tags=None,
9457        username=None,
9458    ):
9459        self.bind_interface = bind_interface if bind_interface is not None else ''
9460        '''
9461         Bind interface
9462        '''
9463        self.database = database if database is not None else ''
9464        self.egress_filter = egress_filter if egress_filter is not None else ''
9465        '''
9466         A filter applied to the routing logic to pin datasource to nodes.
9467        '''
9468        self.healthy = healthy if healthy is not None else False
9469        '''
9470         True if the datasource is reachable and the credentials are valid.
9471        '''
9472        self.hostname = hostname if hostname is not None else ''
9473        self.id = id if id is not None else ''
9474        '''
9475         Unique identifier of the Resource.
9476        '''
9477        self.name = name if name is not None else ''
9478        '''
9479         Unique human-readable name of the Resource.
9480        '''
9481        self.override_database = override_database if override_database is not None else False
9482        self.password = password if password is not None else ''
9483        self.port = port if port is not None else 0
9484        self.port_override = port_override if port_override is not None else 0
9485        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9486        '''
9487         ID of the secret store containing credentials for this resource, if any.
9488        '''
9489        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9490        '''
9491         Tags is a map of key, value pairs.
9492        '''
9493        self.username = username if username is not None else ''
9494
9495    def __repr__(self):
9496        return '<sdm.Redshift ' + \
9497            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9498            'database: ' + repr(self.database) + ' ' +\
9499            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9500            'healthy: ' + repr(self.healthy) + ' ' +\
9501            'hostname: ' + repr(self.hostname) + ' ' +\
9502            'id: ' + repr(self.id) + ' ' +\
9503            'name: ' + repr(self.name) + ' ' +\
9504            'override_database: ' + repr(self.override_database) + ' ' +\
9505            'password: ' + repr(self.password) + ' ' +\
9506            'port: ' + repr(self.port) + ' ' +\
9507            'port_override: ' + repr(self.port_override) + ' ' +\
9508            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9509            'tags: ' + repr(self.tags) + ' ' +\
9510            'username: ' + repr(self.username) + ' ' +\
9511            '>'
9512
9513    def to_dict(self):
9514        return {
9515            'bind_interface': self.bind_interface,
9516            'database': self.database,
9517            'egress_filter': self.egress_filter,
9518            'healthy': self.healthy,
9519            'hostname': self.hostname,
9520            'id': self.id,
9521            'name': self.name,
9522            'override_database': self.override_database,
9523            'password': self.password,
9524            'port': self.port,
9525            'port_override': self.port_override,
9526            'secret_store_id': self.secret_store_id,
9527            'tags': self.tags,
9528            'username': self.username,
9529        }
9530
9531    @classmethod
9532    def from_dict(cls, d):
9533        return cls(
9534            bind_interface=d.get('bind_interface'),
9535            database=d.get('database'),
9536            egress_filter=d.get('egress_filter'),
9537            healthy=d.get('healthy'),
9538            hostname=d.get('hostname'),
9539            id=d.get('id'),
9540            name=d.get('name'),
9541            override_database=d.get('override_database'),
9542            password=d.get('password'),
9543            port=d.get('port'),
9544            port_override=d.get('port_override'),
9545            secret_store_id=d.get('secret_store_id'),
9546            tags=d.get('tags'),
9547            username=d.get('username'),
9548        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9442    def __init__(
9443        self,
9444        bind_interface=None,
9445        database=None,
9446        egress_filter=None,
9447        healthy=None,
9448        hostname=None,
9449        id=None,
9450        name=None,
9451        override_database=None,
9452        password=None,
9453        port=None,
9454        port_override=None,
9455        secret_store_id=None,
9456        tags=None,
9457        username=None,
9458    ):
9459        self.bind_interface = bind_interface if bind_interface is not None else ''
9460        '''
9461         Bind interface
9462        '''
9463        self.database = database if database is not None else ''
9464        self.egress_filter = egress_filter if egress_filter is not None else ''
9465        '''
9466         A filter applied to the routing logic to pin datasource to nodes.
9467        '''
9468        self.healthy = healthy if healthy is not None else False
9469        '''
9470         True if the datasource is reachable and the credentials are valid.
9471        '''
9472        self.hostname = hostname if hostname is not None else ''
9473        self.id = id if id is not None else ''
9474        '''
9475         Unique identifier of the Resource.
9476        '''
9477        self.name = name if name is not None else ''
9478        '''
9479         Unique human-readable name of the Resource.
9480        '''
9481        self.override_database = override_database if override_database is not None else False
9482        self.password = password if password is not None else ''
9483        self.port = port if port is not None else 0
9484        self.port_override = port_override if port_override is not None else 0
9485        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9486        '''
9487         ID of the secret store containing credentials for this resource, if any.
9488        '''
9489        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9490        '''
9491         Tags is a map of key, value pairs.
9492        '''
9493        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9513    def to_dict(self):
9514        return {
9515            'bind_interface': self.bind_interface,
9516            'database': self.database,
9517            'egress_filter': self.egress_filter,
9518            'healthy': self.healthy,
9519            'hostname': self.hostname,
9520            'id': self.id,
9521            'name': self.name,
9522            'override_database': self.override_database,
9523            'password': self.password,
9524            'port': self.port,
9525            'port_override': self.port_override,
9526            'secret_store_id': self.secret_store_id,
9527            'tags': self.tags,
9528            'username': self.username,
9529        }
@classmethod
def from_dict(cls, d)
9531    @classmethod
9532    def from_dict(cls, d):
9533        return cls(
9534            bind_interface=d.get('bind_interface'),
9535            database=d.get('database'),
9536            egress_filter=d.get('egress_filter'),
9537            healthy=d.get('healthy'),
9538            hostname=d.get('hostname'),
9539            id=d.get('id'),
9540            name=d.get('name'),
9541            override_database=d.get('override_database'),
9542            password=d.get('password'),
9543            port=d.get('port'),
9544            port_override=d.get('port_override'),
9545            secret_store_id=d.get('secret_store_id'),
9546            tags=d.get('tags'),
9547            username=d.get('username'),
9548        )
class Relay:
9551class Relay:
9552    '''
9553         Relay represents a StrongDM CLI installation running in relay mode.
9554    '''
9555    __slots__ = [
9556        'gateway_filter',
9557        'id',
9558        'name',
9559        'state',
9560        'tags',
9561    ]
9562
9563    def __init__(
9564        self,
9565        gateway_filter=None,
9566        id=None,
9567        name=None,
9568        state=None,
9569        tags=None,
9570    ):
9571        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9572        '''
9573         GatewayFilter can be used to restrict the peering between relays and
9574         gateways.
9575        '''
9576        self.id = id if id is not None else ''
9577        '''
9578         Unique identifier of the Relay.
9579        '''
9580        self.name = name if name is not None else ''
9581        '''
9582         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9583        '''
9584        self.state = state if state is not None else ''
9585        '''
9586         The current state of the relay. One of: "new", "verifying_restart",
9587         "awaiting_restart", "restarting", "started", "stopped", "dead",
9588         "unknown".
9589        '''
9590        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9591        '''
9592         Tags is a map of key, value pairs.
9593        '''
9594
9595    def __repr__(self):
9596        return '<sdm.Relay ' + \
9597            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9598            'id: ' + repr(self.id) + ' ' +\
9599            'name: ' + repr(self.name) + ' ' +\
9600            'state: ' + repr(self.state) + ' ' +\
9601            'tags: ' + repr(self.tags) + ' ' +\
9602            '>'
9603
9604    def to_dict(self):
9605        return {
9606            'gateway_filter': self.gateway_filter,
9607            'id': self.id,
9608            'name': self.name,
9609            'state': self.state,
9610            'tags': self.tags,
9611        }
9612
9613    @classmethod
9614    def from_dict(cls, d):
9615        return cls(
9616            gateway_filter=d.get('gateway_filter'),
9617            id=d.get('id'),
9618            name=d.get('name'),
9619            state=d.get('state'),
9620            tags=d.get('tags'),
9621        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
9563    def __init__(
9564        self,
9565        gateway_filter=None,
9566        id=None,
9567        name=None,
9568        state=None,
9569        tags=None,
9570    ):
9571        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9572        '''
9573         GatewayFilter can be used to restrict the peering between relays and
9574         gateways.
9575        '''
9576        self.id = id if id is not None else ''
9577        '''
9578         Unique identifier of the Relay.
9579        '''
9580        self.name = name if name is not None else ''
9581        '''
9582         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9583        '''
9584        self.state = state if state is not None else ''
9585        '''
9586         The current state of the relay. One of: "new", "verifying_restart",
9587         "awaiting_restart", "restarting", "started", "stopped", "dead",
9588         "unknown".
9589        '''
9590        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9591        '''
9592         Tags is a map of key, value pairs.
9593        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
9604    def to_dict(self):
9605        return {
9606            'gateway_filter': self.gateway_filter,
9607            'id': self.id,
9608            'name': self.name,
9609            'state': self.state,
9610            'tags': self.tags,
9611        }
@classmethod
def from_dict(cls, d)
9613    @classmethod
9614    def from_dict(cls, d):
9615        return cls(
9616            gateway_filter=d.get('gateway_filter'),
9617            id=d.get('id'),
9618            name=d.get('name'),
9619            state=d.get('state'),
9620            tags=d.get('tags'),
9621        )
class RemoteIdentity:
9624class RemoteIdentity:
9625    '''
9626         RemoteIdentities define the username to be used for a specific account
9627     when connecting to a remote resource using that group.
9628    '''
9629    __slots__ = [
9630        'account_id',
9631        'id',
9632        'remote_identity_group_id',
9633        'username',
9634    ]
9635
9636    def __init__(
9637        self,
9638        account_id=None,
9639        id=None,
9640        remote_identity_group_id=None,
9641        username=None,
9642    ):
9643        self.account_id = account_id if account_id is not None else ''
9644        '''
9645         The account for this remote identity.
9646        '''
9647        self.id = id if id is not None else ''
9648        '''
9649         Unique identifier of the RemoteIdentity.
9650        '''
9651        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9652        '''
9653         The remote identity group.
9654        '''
9655        self.username = username if username is not None else ''
9656        '''
9657         The username to be used as the remote identity for this account.
9658        '''
9659
9660    def __repr__(self):
9661        return '<sdm.RemoteIdentity ' + \
9662            'account_id: ' + repr(self.account_id) + ' ' +\
9663            'id: ' + repr(self.id) + ' ' +\
9664            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9665            'username: ' + repr(self.username) + ' ' +\
9666            '>'
9667
9668    def to_dict(self):
9669        return {
9670            'account_id': self.account_id,
9671            'id': self.id,
9672            'remote_identity_group_id': self.remote_identity_group_id,
9673            'username': self.username,
9674        }
9675
9676    @classmethod
9677    def from_dict(cls, d):
9678        return cls(
9679            account_id=d.get('account_id'),
9680            id=d.get('id'),
9681            remote_identity_group_id=d.get('remote_identity_group_id'),
9682            username=d.get('username'),
9683        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9636    def __init__(
9637        self,
9638        account_id=None,
9639        id=None,
9640        remote_identity_group_id=None,
9641        username=None,
9642    ):
9643        self.account_id = account_id if account_id is not None else ''
9644        '''
9645         The account for this remote identity.
9646        '''
9647        self.id = id if id is not None else ''
9648        '''
9649         Unique identifier of the RemoteIdentity.
9650        '''
9651        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9652        '''
9653         The remote identity group.
9654        '''
9655        self.username = username if username is not None else ''
9656        '''
9657         The username to be used as the remote identity for this account.
9658        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9668    def to_dict(self):
9669        return {
9670            'account_id': self.account_id,
9671            'id': self.id,
9672            'remote_identity_group_id': self.remote_identity_group_id,
9673            'username': self.username,
9674        }
@classmethod
def from_dict(cls, d)
9676    @classmethod
9677    def from_dict(cls, d):
9678        return cls(
9679            account_id=d.get('account_id'),
9680            id=d.get('id'),
9681            remote_identity_group_id=d.get('remote_identity_group_id'),
9682            username=d.get('username'),
9683        )
class RemoteIdentityCreateResponse:
9686class RemoteIdentityCreateResponse:
9687    '''
9688         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9689    '''
9690    __slots__ = [
9691        'meta',
9692        'rate_limit',
9693        'remote_identity',
9694    ]
9695
9696    def __init__(
9697        self,
9698        meta=None,
9699        rate_limit=None,
9700        remote_identity=None,
9701    ):
9702        self.meta = meta if meta is not None else None
9703        '''
9704         Reserved for future use.
9705        '''
9706        self.rate_limit = rate_limit if rate_limit is not None else None
9707        '''
9708         Rate limit information.
9709        '''
9710        self.remote_identity = remote_identity if remote_identity is not None else None
9711        '''
9712         The created RemoteIdentity.
9713        '''
9714
9715    def __repr__(self):
9716        return '<sdm.RemoteIdentityCreateResponse ' + \
9717            'meta: ' + repr(self.meta) + ' ' +\
9718            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9719            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9720            '>'
9721
9722    def to_dict(self):
9723        return {
9724            'meta': self.meta,
9725            'rate_limit': self.rate_limit,
9726            'remote_identity': self.remote_identity,
9727        }
9728
9729    @classmethod
9730    def from_dict(cls, d):
9731        return cls(
9732            meta=d.get('meta'),
9733            rate_limit=d.get('rate_limit'),
9734            remote_identity=d.get('remote_identity'),
9735        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9696    def __init__(
9697        self,
9698        meta=None,
9699        rate_limit=None,
9700        remote_identity=None,
9701    ):
9702        self.meta = meta if meta is not None else None
9703        '''
9704         Reserved for future use.
9705        '''
9706        self.rate_limit = rate_limit if rate_limit is not None else None
9707        '''
9708         Rate limit information.
9709        '''
9710        self.remote_identity = remote_identity if remote_identity is not None else None
9711        '''
9712         The created RemoteIdentity.
9713        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9722    def to_dict(self):
9723        return {
9724            'meta': self.meta,
9725            'rate_limit': self.rate_limit,
9726            'remote_identity': self.remote_identity,
9727        }
@classmethod
def from_dict(cls, d)
9729    @classmethod
9730    def from_dict(cls, d):
9731        return cls(
9732            meta=d.get('meta'),
9733            rate_limit=d.get('rate_limit'),
9734            remote_identity=d.get('remote_identity'),
9735        )
class RemoteIdentityDeleteResponse:
9738class RemoteIdentityDeleteResponse:
9739    '''
9740         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
9741    '''
9742    __slots__ = [
9743        'meta',
9744        'rate_limit',
9745    ]
9746
9747    def __init__(
9748        self,
9749        meta=None,
9750        rate_limit=None,
9751    ):
9752        self.meta = meta if meta is not None else None
9753        '''
9754         Reserved for future use.
9755        '''
9756        self.rate_limit = rate_limit if rate_limit is not None else None
9757        '''
9758         Rate limit information.
9759        '''
9760
9761    def __repr__(self):
9762        return '<sdm.RemoteIdentityDeleteResponse ' + \
9763            'meta: ' + repr(self.meta) + ' ' +\
9764            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9765            '>'
9766
9767    def to_dict(self):
9768        return {
9769            'meta': self.meta,
9770            'rate_limit': self.rate_limit,
9771        }
9772
9773    @classmethod
9774    def from_dict(cls, d):
9775        return cls(
9776            meta=d.get('meta'),
9777            rate_limit=d.get('rate_limit'),
9778        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
9747    def __init__(
9748        self,
9749        meta=None,
9750        rate_limit=None,
9751    ):
9752        self.meta = meta if meta is not None else None
9753        '''
9754         Reserved for future use.
9755        '''
9756        self.rate_limit = rate_limit if rate_limit is not None else None
9757        '''
9758         Rate limit information.
9759        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9767    def to_dict(self):
9768        return {
9769            'meta': self.meta,
9770            'rate_limit': self.rate_limit,
9771        }
@classmethod
def from_dict(cls, d)
9773    @classmethod
9774    def from_dict(cls, d):
9775        return cls(
9776            meta=d.get('meta'),
9777            rate_limit=d.get('rate_limit'),
9778        )
class RemoteIdentityGetResponse:
9781class RemoteIdentityGetResponse:
9782    '''
9783         RemoteIdentityGetResponse returns a requested RemoteIdentity.
9784    '''
9785    __slots__ = [
9786        'meta',
9787        'rate_limit',
9788        'remote_identity',
9789    ]
9790
9791    def __init__(
9792        self,
9793        meta=None,
9794        rate_limit=None,
9795        remote_identity=None,
9796    ):
9797        self.meta = meta if meta is not None else None
9798        '''
9799         Reserved for future use.
9800        '''
9801        self.rate_limit = rate_limit if rate_limit is not None else None
9802        '''
9803         Rate limit information.
9804        '''
9805        self.remote_identity = remote_identity if remote_identity is not None else None
9806        '''
9807         The requested RemoteIdentity.
9808        '''
9809
9810    def __repr__(self):
9811        return '<sdm.RemoteIdentityGetResponse ' + \
9812            'meta: ' + repr(self.meta) + ' ' +\
9813            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9814            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9815            '>'
9816
9817    def to_dict(self):
9818        return {
9819            'meta': self.meta,
9820            'rate_limit': self.rate_limit,
9821            'remote_identity': self.remote_identity,
9822        }
9823
9824    @classmethod
9825    def from_dict(cls, d):
9826        return cls(
9827            meta=d.get('meta'),
9828            rate_limit=d.get('rate_limit'),
9829            remote_identity=d.get('remote_identity'),
9830        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
9791    def __init__(
9792        self,
9793        meta=None,
9794        rate_limit=None,
9795        remote_identity=None,
9796    ):
9797        self.meta = meta if meta is not None else None
9798        '''
9799         Reserved for future use.
9800        '''
9801        self.rate_limit = rate_limit if rate_limit is not None else None
9802        '''
9803         Rate limit information.
9804        '''
9805        self.remote_identity = remote_identity if remote_identity is not None else None
9806        '''
9807         The requested RemoteIdentity.
9808        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
9817    def to_dict(self):
9818        return {
9819            'meta': self.meta,
9820            'rate_limit': self.rate_limit,
9821            'remote_identity': self.remote_identity,
9822        }
@classmethod
def from_dict(cls, d)
9824    @classmethod
9825    def from_dict(cls, d):
9826        return cls(
9827            meta=d.get('meta'),
9828            rate_limit=d.get('rate_limit'),
9829            remote_identity=d.get('remote_identity'),
9830        )
class RemoteIdentityGroup:
9833class RemoteIdentityGroup:
9834    '''
9835         A RemoteIdentityGroup defines a group of remote identities.
9836    '''
9837    __slots__ = [
9838        'id',
9839        'name',
9840    ]
9841
9842    def __init__(
9843        self,
9844        id=None,
9845        name=None,
9846    ):
9847        self.id = id if id is not None else ''
9848        '''
9849         Unique identifier of the RemoteIdentityGroup.
9850        '''
9851        self.name = name if name is not None else ''
9852        '''
9853         Unique human-readable name of the RemoteIdentityGroup.
9854        '''
9855
9856    def __repr__(self):
9857        return '<sdm.RemoteIdentityGroup ' + \
9858            'id: ' + repr(self.id) + ' ' +\
9859            'name: ' + repr(self.name) + ' ' +\
9860            '>'
9861
9862    def to_dict(self):
9863        return {
9864            'id': self.id,
9865            'name': self.name,
9866        }
9867
9868    @classmethod
9869    def from_dict(cls, d):
9870        return cls(
9871            id=d.get('id'),
9872            name=d.get('name'),
9873        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
9842    def __init__(
9843        self,
9844        id=None,
9845        name=None,
9846    ):
9847        self.id = id if id is not None else ''
9848        '''
9849         Unique identifier of the RemoteIdentityGroup.
9850        '''
9851        self.name = name if name is not None else ''
9852        '''
9853         Unique human-readable name of the RemoteIdentityGroup.
9854        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
9862    def to_dict(self):
9863        return {
9864            'id': self.id,
9865            'name': self.name,
9866        }
@classmethod
def from_dict(cls, d)
9868    @classmethod
9869    def from_dict(cls, d):
9870        return cls(
9871            id=d.get('id'),
9872            name=d.get('name'),
9873        )
class RemoteIdentityGroupGetResponse:
9876class RemoteIdentityGroupGetResponse:
9877    '''
9878         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
9879    '''
9880    __slots__ = [
9881        'meta',
9882        'rate_limit',
9883        'remote_identity_group',
9884    ]
9885
9886    def __init__(
9887        self,
9888        meta=None,
9889        rate_limit=None,
9890        remote_identity_group=None,
9891    ):
9892        self.meta = meta if meta is not None else None
9893        '''
9894         Reserved for future use.
9895        '''
9896        self.rate_limit = rate_limit if rate_limit is not None else None
9897        '''
9898         Rate limit information.
9899        '''
9900        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9901        '''
9902         The requested RemoteIdentityGroup.
9903        '''
9904
9905    def __repr__(self):
9906        return '<sdm.RemoteIdentityGroupGetResponse ' + \
9907            'meta: ' + repr(self.meta) + ' ' +\
9908            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9909            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
9910            '>'
9911
9912    def to_dict(self):
9913        return {
9914            'meta': self.meta,
9915            'rate_limit': self.rate_limit,
9916            'remote_identity_group': self.remote_identity_group,
9917        }
9918
9919    @classmethod
9920    def from_dict(cls, d):
9921        return cls(
9922            meta=d.get('meta'),
9923            rate_limit=d.get('rate_limit'),
9924            remote_identity_group=d.get('remote_identity_group'),
9925        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
9886    def __init__(
9887        self,
9888        meta=None,
9889        rate_limit=None,
9890        remote_identity_group=None,
9891    ):
9892        self.meta = meta if meta is not None else None
9893        '''
9894         Reserved for future use.
9895        '''
9896        self.rate_limit = rate_limit if rate_limit is not None else None
9897        '''
9898         Rate limit information.
9899        '''
9900        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9901        '''
9902         The requested RemoteIdentityGroup.
9903        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
9912    def to_dict(self):
9913        return {
9914            'meta': self.meta,
9915            'rate_limit': self.rate_limit,
9916            'remote_identity_group': self.remote_identity_group,
9917        }
@classmethod
def from_dict(cls, d)
9919    @classmethod
9920    def from_dict(cls, d):
9921        return cls(
9922            meta=d.get('meta'),
9923            rate_limit=d.get('rate_limit'),
9924            remote_identity_group=d.get('remote_identity_group'),
9925        )
class RemoteIdentityUpdateResponse:
9928class RemoteIdentityUpdateResponse:
9929    '''
9930         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
9931     a RemoteIdentityUpdateRequest.
9932    '''
9933    __slots__ = [
9934        'meta',
9935        'rate_limit',
9936        'remote_identity',
9937    ]
9938
9939    def __init__(
9940        self,
9941        meta=None,
9942        rate_limit=None,
9943        remote_identity=None,
9944    ):
9945        self.meta = meta if meta is not None else None
9946        '''
9947         Reserved for future use.
9948        '''
9949        self.rate_limit = rate_limit if rate_limit is not None else None
9950        '''
9951         Rate limit information.
9952        '''
9953        self.remote_identity = remote_identity if remote_identity is not None else None
9954        '''
9955         The updated RemoteIdentity.
9956        '''
9957
9958    def __repr__(self):
9959        return '<sdm.RemoteIdentityUpdateResponse ' + \
9960            'meta: ' + repr(self.meta) + ' ' +\
9961            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9962            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9963            '>'
9964
9965    def to_dict(self):
9966        return {
9967            'meta': self.meta,
9968            'rate_limit': self.rate_limit,
9969            'remote_identity': self.remote_identity,
9970        }
9971
9972    @classmethod
9973    def from_dict(cls, d):
9974        return cls(
9975            meta=d.get('meta'),
9976            rate_limit=d.get('rate_limit'),
9977            remote_identity=d.get('remote_identity'),
9978        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
9939    def __init__(
9940        self,
9941        meta=None,
9942        rate_limit=None,
9943        remote_identity=None,
9944    ):
9945        self.meta = meta if meta is not None else None
9946        '''
9947         Reserved for future use.
9948        '''
9949        self.rate_limit = rate_limit if rate_limit is not None else None
9950        '''
9951         Rate limit information.
9952        '''
9953        self.remote_identity = remote_identity if remote_identity is not None else None
9954        '''
9955         The updated RemoteIdentity.
9956        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
9965    def to_dict(self):
9966        return {
9967            'meta': self.meta,
9968            'rate_limit': self.rate_limit,
9969            'remote_identity': self.remote_identity,
9970        }
@classmethod
def from_dict(cls, d)
9972    @classmethod
9973    def from_dict(cls, d):
9974        return cls(
9975            meta=d.get('meta'),
9976            rate_limit=d.get('rate_limit'),
9977            remote_identity=d.get('remote_identity'),
9978        )
class ResourceCreateResponse:
 9981class ResourceCreateResponse:
 9982    '''
 9983         ResourceCreateResponse reports how the Resources were created in the system.
 9984    '''
 9985    __slots__ = [
 9986        'meta',
 9987        'rate_limit',
 9988        'resource',
 9989    ]
 9990
 9991    def __init__(
 9992        self,
 9993        meta=None,
 9994        rate_limit=None,
 9995        resource=None,
 9996    ):
 9997        self.meta = meta if meta is not None else None
 9998        '''
 9999         Reserved for future use.
10000        '''
10001        self.rate_limit = rate_limit if rate_limit is not None else None
10002        '''
10003         Rate limit information.
10004        '''
10005        self.resource = resource if resource is not None else None
10006        '''
10007         The created Resource.
10008        '''
10009
10010    def __repr__(self):
10011        return '<sdm.ResourceCreateResponse ' + \
10012            'meta: ' + repr(self.meta) + ' ' +\
10013            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10014            'resource: ' + repr(self.resource) + ' ' +\
10015            '>'
10016
10017    def to_dict(self):
10018        return {
10019            'meta': self.meta,
10020            'rate_limit': self.rate_limit,
10021            'resource': self.resource,
10022        }
10023
10024    @classmethod
10025    def from_dict(cls, d):
10026        return cls(
10027            meta=d.get('meta'),
10028            rate_limit=d.get('rate_limit'),
10029            resource=d.get('resource'),
10030        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
 9991    def __init__(
 9992        self,
 9993        meta=None,
 9994        rate_limit=None,
 9995        resource=None,
 9996    ):
 9997        self.meta = meta if meta is not None else None
 9998        '''
 9999         Reserved for future use.
10000        '''
10001        self.rate_limit = rate_limit if rate_limit is not None else None
10002        '''
10003         Rate limit information.
10004        '''
10005        self.resource = resource if resource is not None else None
10006        '''
10007         The created Resource.
10008        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10017    def to_dict(self):
10018        return {
10019            'meta': self.meta,
10020            'rate_limit': self.rate_limit,
10021            'resource': self.resource,
10022        }
@classmethod
def from_dict(cls, d)
10024    @classmethod
10025    def from_dict(cls, d):
10026        return cls(
10027            meta=d.get('meta'),
10028            rate_limit=d.get('rate_limit'),
10029            resource=d.get('resource'),
10030        )
class ResourceDeleteResponse:
10033class ResourceDeleteResponse:
10034    '''
10035         ResourceDeleteResponse returns information about a Resource that was deleted.
10036    '''
10037    __slots__ = [
10038        'meta',
10039        'rate_limit',
10040    ]
10041
10042    def __init__(
10043        self,
10044        meta=None,
10045        rate_limit=None,
10046    ):
10047        self.meta = meta if meta is not None else None
10048        '''
10049         Reserved for future use.
10050        '''
10051        self.rate_limit = rate_limit if rate_limit is not None else None
10052        '''
10053         Rate limit information.
10054        '''
10055
10056    def __repr__(self):
10057        return '<sdm.ResourceDeleteResponse ' + \
10058            'meta: ' + repr(self.meta) + ' ' +\
10059            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10060            '>'
10061
10062    def to_dict(self):
10063        return {
10064            'meta': self.meta,
10065            'rate_limit': self.rate_limit,
10066        }
10067
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10042    def __init__(
10043        self,
10044        meta=None,
10045        rate_limit=None,
10046    ):
10047        self.meta = meta if meta is not None else None
10048        '''
10049         Reserved for future use.
10050        '''
10051        self.rate_limit = rate_limit if rate_limit is not None else None
10052        '''
10053         Rate limit information.
10054        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10062    def to_dict(self):
10063        return {
10064            'meta': self.meta,
10065            'rate_limit': self.rate_limit,
10066        }
@classmethod
def from_dict(cls, d)
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073        )
class ResourceGetResponse:
10076class ResourceGetResponse:
10077    '''
10078         ResourceGetResponse returns a requested Resource.
10079    '''
10080    __slots__ = [
10081        'meta',
10082        'rate_limit',
10083        'resource',
10084    ]
10085
10086    def __init__(
10087        self,
10088        meta=None,
10089        rate_limit=None,
10090        resource=None,
10091    ):
10092        self.meta = meta if meta is not None else None
10093        '''
10094         Reserved for future use.
10095        '''
10096        self.rate_limit = rate_limit if rate_limit is not None else None
10097        '''
10098         Rate limit information.
10099        '''
10100        self.resource = resource if resource is not None else None
10101        '''
10102         The requested Resource.
10103        '''
10104
10105    def __repr__(self):
10106        return '<sdm.ResourceGetResponse ' + \
10107            'meta: ' + repr(self.meta) + ' ' +\
10108            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10109            'resource: ' + repr(self.resource) + ' ' +\
10110            '>'
10111
10112    def to_dict(self):
10113        return {
10114            'meta': self.meta,
10115            'rate_limit': self.rate_limit,
10116            'resource': self.resource,
10117        }
10118
10119    @classmethod
10120    def from_dict(cls, d):
10121        return cls(
10122            meta=d.get('meta'),
10123            rate_limit=d.get('rate_limit'),
10124            resource=d.get('resource'),
10125        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10086    def __init__(
10087        self,
10088        meta=None,
10089        rate_limit=None,
10090        resource=None,
10091    ):
10092        self.meta = meta if meta is not None else None
10093        '''
10094         Reserved for future use.
10095        '''
10096        self.rate_limit = rate_limit if rate_limit is not None else None
10097        '''
10098         Rate limit information.
10099        '''
10100        self.resource = resource if resource is not None else None
10101        '''
10102         The requested Resource.
10103        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10112    def to_dict(self):
10113        return {
10114            'meta': self.meta,
10115            'rate_limit': self.rate_limit,
10116            'resource': self.resource,
10117        }
@classmethod
def from_dict(cls, d)
10119    @classmethod
10120    def from_dict(cls, d):
10121        return cls(
10122            meta=d.get('meta'),
10123            rate_limit=d.get('rate_limit'),
10124            resource=d.get('resource'),
10125        )
class ResourceUpdateResponse:
10128class ResourceUpdateResponse:
10129    '''
10130         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10131     a ResourceUpdateRequest.
10132    '''
10133    __slots__ = [
10134        'meta',
10135        'rate_limit',
10136        'resource',
10137    ]
10138
10139    def __init__(
10140        self,
10141        meta=None,
10142        rate_limit=None,
10143        resource=None,
10144    ):
10145        self.meta = meta if meta is not None else None
10146        '''
10147         Reserved for future use.
10148        '''
10149        self.rate_limit = rate_limit if rate_limit is not None else None
10150        '''
10151         Rate limit information.
10152        '''
10153        self.resource = resource if resource is not None else None
10154        '''
10155         The updated Resource.
10156        '''
10157
10158    def __repr__(self):
10159        return '<sdm.ResourceUpdateResponse ' + \
10160            'meta: ' + repr(self.meta) + ' ' +\
10161            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10162            'resource: ' + repr(self.resource) + ' ' +\
10163            '>'
10164
10165    def to_dict(self):
10166        return {
10167            'meta': self.meta,
10168            'rate_limit': self.rate_limit,
10169            'resource': self.resource,
10170        }
10171
10172    @classmethod
10173    def from_dict(cls, d):
10174        return cls(
10175            meta=d.get('meta'),
10176            rate_limit=d.get('rate_limit'),
10177            resource=d.get('resource'),
10178        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10139    def __init__(
10140        self,
10141        meta=None,
10142        rate_limit=None,
10143        resource=None,
10144    ):
10145        self.meta = meta if meta is not None else None
10146        '''
10147         Reserved for future use.
10148        '''
10149        self.rate_limit = rate_limit if rate_limit is not None else None
10150        '''
10151         Rate limit information.
10152        '''
10153        self.resource = resource if resource is not None else None
10154        '''
10155         The updated Resource.
10156        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10165    def to_dict(self):
10166        return {
10167            'meta': self.meta,
10168            'rate_limit': self.rate_limit,
10169            'resource': self.resource,
10170        }
@classmethod
def from_dict(cls, d)
10172    @classmethod
10173    def from_dict(cls, d):
10174        return cls(
10175            meta=d.get('meta'),
10176            rate_limit=d.get('rate_limit'),
10177            resource=d.get('resource'),
10178        )
class Role:
10181class Role:
10182    '''
10183         A Role has a list of access rules which determine which Resources the members
10184     of the Role have access to. An Account can be a member of multiple Roles via
10185     AccountAttachments.
10186    '''
10187    __slots__ = [
10188        'access_rules',
10189        'id',
10190        'name',
10191        'tags',
10192    ]
10193
10194    def __init__(
10195        self,
10196        access_rules=None,
10197        id=None,
10198        name=None,
10199        tags=None,
10200    ):
10201        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10202        )
10203        '''
10204         AccessRules is a list of access rules defining the resources this Role has access to.
10205        '''
10206        self.id = id if id is not None else ''
10207        '''
10208         Unique identifier of the Role.
10209        '''
10210        self.name = name if name is not None else ''
10211        '''
10212         Unique human-readable name of the Role.
10213        '''
10214        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10215        '''
10216         Tags is a map of key, value pairs.
10217        '''
10218
10219    def __repr__(self):
10220        return '<sdm.Role ' + \
10221            'access_rules: ' + repr(self.access_rules) + ' ' +\
10222            'id: ' + repr(self.id) + ' ' +\
10223            'name: ' + repr(self.name) + ' ' +\
10224            'tags: ' + repr(self.tags) + ' ' +\
10225            '>'
10226
10227    def to_dict(self):
10228        return {
10229            'access_rules': self.access_rules,
10230            'id': self.id,
10231            'name': self.name,
10232            'tags': self.tags,
10233        }
10234
10235    @classmethod
10236    def from_dict(cls, d):
10237        return cls(
10238            access_rules=d.get('access_rules'),
10239            id=d.get('id'),
10240            name=d.get('name'),
10241            tags=d.get('tags'),
10242        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, name=None, tags=None)
10194    def __init__(
10195        self,
10196        access_rules=None,
10197        id=None,
10198        name=None,
10199        tags=None,
10200    ):
10201        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10202        )
10203        '''
10204         AccessRules is a list of access rules defining the resources this Role has access to.
10205        '''
10206        self.id = id if id is not None else ''
10207        '''
10208         Unique identifier of the Role.
10209        '''
10210        self.name = name if name is not None else ''
10211        '''
10212         Unique human-readable name of the Role.
10213        '''
10214        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10215        '''
10216         Tags is a map of key, value pairs.
10217        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10227    def to_dict(self):
10228        return {
10229            'access_rules': self.access_rules,
10230            'id': self.id,
10231            'name': self.name,
10232            'tags': self.tags,
10233        }
@classmethod
def from_dict(cls, d)
10235    @classmethod
10236    def from_dict(cls, d):
10237        return cls(
10238            access_rules=d.get('access_rules'),
10239            id=d.get('id'),
10240            name=d.get('name'),
10241            tags=d.get('tags'),
10242        )
class RoleCreateResponse:
10245class RoleCreateResponse:
10246    '''
10247         RoleCreateResponse reports how the Roles were created in the system. It can
10248     communicate partial successes or failures.
10249    '''
10250    __slots__ = [
10251        'meta',
10252        'rate_limit',
10253        'role',
10254    ]
10255
10256    def __init__(
10257        self,
10258        meta=None,
10259        rate_limit=None,
10260        role=None,
10261    ):
10262        self.meta = meta if meta is not None else None
10263        '''
10264         Reserved for future use.
10265        '''
10266        self.rate_limit = rate_limit if rate_limit is not None else None
10267        '''
10268         Rate limit information.
10269        '''
10270        self.role = role if role is not None else None
10271        '''
10272         The created Role.
10273        '''
10274
10275    def __repr__(self):
10276        return '<sdm.RoleCreateResponse ' + \
10277            'meta: ' + repr(self.meta) + ' ' +\
10278            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10279            'role: ' + repr(self.role) + ' ' +\
10280            '>'
10281
10282    def to_dict(self):
10283        return {
10284            'meta': self.meta,
10285            'rate_limit': self.rate_limit,
10286            'role': self.role,
10287        }
10288
10289    @classmethod
10290    def from_dict(cls, d):
10291        return cls(
10292            meta=d.get('meta'),
10293            rate_limit=d.get('rate_limit'),
10294            role=d.get('role'),
10295        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
10256    def __init__(
10257        self,
10258        meta=None,
10259        rate_limit=None,
10260        role=None,
10261    ):
10262        self.meta = meta if meta is not None else None
10263        '''
10264         Reserved for future use.
10265        '''
10266        self.rate_limit = rate_limit if rate_limit is not None else None
10267        '''
10268         Rate limit information.
10269        '''
10270        self.role = role if role is not None else None
10271        '''
10272         The created Role.
10273        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
10282    def to_dict(self):
10283        return {
10284            'meta': self.meta,
10285            'rate_limit': self.rate_limit,
10286            'role': self.role,
10287        }
@classmethod
def from_dict(cls, d)
10289    @classmethod
10290    def from_dict(cls, d):
10291        return cls(
10292            meta=d.get('meta'),
10293            rate_limit=d.get('rate_limit'),
10294            role=d.get('role'),
10295        )
class RoleDeleteResponse:
10298class RoleDeleteResponse:
10299    '''
10300         RoleDeleteResponse returns information about a Role that was deleted.
10301    '''
10302    __slots__ = [
10303        'meta',
10304        'rate_limit',
10305    ]
10306
10307    def __init__(
10308        self,
10309        meta=None,
10310        rate_limit=None,
10311    ):
10312        self.meta = meta if meta is not None else None
10313        '''
10314         Reserved for future use.
10315        '''
10316        self.rate_limit = rate_limit if rate_limit is not None else None
10317        '''
10318         Rate limit information.
10319        '''
10320
10321    def __repr__(self):
10322        return '<sdm.RoleDeleteResponse ' + \
10323            'meta: ' + repr(self.meta) + ' ' +\
10324            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10325            '>'
10326
10327    def to_dict(self):
10328        return {
10329            'meta': self.meta,
10330            'rate_limit': self.rate_limit,
10331        }
10332
10333    @classmethod
10334    def from_dict(cls, d):
10335        return cls(
10336            meta=d.get('meta'),
10337            rate_limit=d.get('rate_limit'),
10338        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
10307    def __init__(
10308        self,
10309        meta=None,
10310        rate_limit=None,
10311    ):
10312        self.meta = meta if meta is not None else None
10313        '''
10314         Reserved for future use.
10315        '''
10316        self.rate_limit = rate_limit if rate_limit is not None else None
10317        '''
10318         Rate limit information.
10319        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10327    def to_dict(self):
10328        return {
10329            'meta': self.meta,
10330            'rate_limit': self.rate_limit,
10331        }
@classmethod
def from_dict(cls, d)
10333    @classmethod
10334    def from_dict(cls, d):
10335        return cls(
10336            meta=d.get('meta'),
10337            rate_limit=d.get('rate_limit'),
10338        )
class RoleGetResponse:
10341class RoleGetResponse:
10342    '''
10343         RoleGetResponse returns a requested Role.
10344    '''
10345    __slots__ = [
10346        'meta',
10347        'rate_limit',
10348        'role',
10349    ]
10350
10351    def __init__(
10352        self,
10353        meta=None,
10354        rate_limit=None,
10355        role=None,
10356    ):
10357        self.meta = meta if meta is not None else None
10358        '''
10359         Reserved for future use.
10360        '''
10361        self.rate_limit = rate_limit if rate_limit is not None else None
10362        '''
10363         Rate limit information.
10364        '''
10365        self.role = role if role is not None else None
10366        '''
10367         The requested Role.
10368        '''
10369
10370    def __repr__(self):
10371        return '<sdm.RoleGetResponse ' + \
10372            'meta: ' + repr(self.meta) + ' ' +\
10373            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10374            'role: ' + repr(self.role) + ' ' +\
10375            '>'
10376
10377    def to_dict(self):
10378        return {
10379            'meta': self.meta,
10380            'rate_limit': self.rate_limit,
10381            'role': self.role,
10382        }
10383
10384    @classmethod
10385    def from_dict(cls, d):
10386        return cls(
10387            meta=d.get('meta'),
10388            rate_limit=d.get('rate_limit'),
10389            role=d.get('role'),
10390        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10351    def __init__(
10352        self,
10353        meta=None,
10354        rate_limit=None,
10355        role=None,
10356    ):
10357        self.meta = meta if meta is not None else None
10358        '''
10359         Reserved for future use.
10360        '''
10361        self.rate_limit = rate_limit if rate_limit is not None else None
10362        '''
10363         Rate limit information.
10364        '''
10365        self.role = role if role is not None else None
10366        '''
10367         The requested Role.
10368        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10377    def to_dict(self):
10378        return {
10379            'meta': self.meta,
10380            'rate_limit': self.rate_limit,
10381            'role': self.role,
10382        }
@classmethod
def from_dict(cls, d)
10384    @classmethod
10385    def from_dict(cls, d):
10386        return cls(
10387            meta=d.get('meta'),
10388            rate_limit=d.get('rate_limit'),
10389            role=d.get('role'),
10390        )
class RoleUpdateResponse:
10393class RoleUpdateResponse:
10394    '''
10395         RoleUpdateResponse returns the fields of a Role after it has been updated by
10396     a RoleUpdateRequest.
10397    '''
10398    __slots__ = [
10399        'meta',
10400        'rate_limit',
10401        'role',
10402    ]
10403
10404    def __init__(
10405        self,
10406        meta=None,
10407        rate_limit=None,
10408        role=None,
10409    ):
10410        self.meta = meta if meta is not None else None
10411        '''
10412         Reserved for future use.
10413        '''
10414        self.rate_limit = rate_limit if rate_limit is not None else None
10415        '''
10416         Rate limit information.
10417        '''
10418        self.role = role if role is not None else None
10419        '''
10420         The updated Role.
10421        '''
10422
10423    def __repr__(self):
10424        return '<sdm.RoleUpdateResponse ' + \
10425            'meta: ' + repr(self.meta) + ' ' +\
10426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10427            'role: ' + repr(self.role) + ' ' +\
10428            '>'
10429
10430    def to_dict(self):
10431        return {
10432            'meta': self.meta,
10433            'rate_limit': self.rate_limit,
10434            'role': self.role,
10435        }
10436
10437    @classmethod
10438    def from_dict(cls, d):
10439        return cls(
10440            meta=d.get('meta'),
10441            rate_limit=d.get('rate_limit'),
10442            role=d.get('role'),
10443        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10404    def __init__(
10405        self,
10406        meta=None,
10407        rate_limit=None,
10408        role=None,
10409    ):
10410        self.meta = meta if meta is not None else None
10411        '''
10412         Reserved for future use.
10413        '''
10414        self.rate_limit = rate_limit if rate_limit is not None else None
10415        '''
10416         Rate limit information.
10417        '''
10418        self.role = role if role is not None else None
10419        '''
10420         The updated Role.
10421        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10430    def to_dict(self):
10431        return {
10432            'meta': self.meta,
10433            'rate_limit': self.rate_limit,
10434            'role': self.role,
10435        }
@classmethod
def from_dict(cls, d)
10437    @classmethod
10438    def from_dict(cls, d):
10439        return cls(
10440            meta=d.get('meta'),
10441            rate_limit=d.get('rate_limit'),
10442            role=d.get('role'),
10443        )
class SQLServer:
10446class SQLServer:
10447    __slots__ = [
10448        'bind_interface',
10449        'database',
10450        'egress_filter',
10451        'healthy',
10452        'hostname',
10453        'id',
10454        'name',
10455        'override_database',
10456        'password',
10457        'port',
10458        'port_override',
10459        'schema',
10460        'secret_store_id',
10461        'tags',
10462        'username',
10463    ]
10464
10465    def __init__(
10466        self,
10467        bind_interface=None,
10468        database=None,
10469        egress_filter=None,
10470        healthy=None,
10471        hostname=None,
10472        id=None,
10473        name=None,
10474        override_database=None,
10475        password=None,
10476        port=None,
10477        port_override=None,
10478        schema=None,
10479        secret_store_id=None,
10480        tags=None,
10481        username=None,
10482    ):
10483        self.bind_interface = bind_interface if bind_interface is not None else ''
10484        '''
10485         Bind interface
10486        '''
10487        self.database = database if database is not None else ''
10488        self.egress_filter = egress_filter if egress_filter is not None else ''
10489        '''
10490         A filter applied to the routing logic to pin datasource to nodes.
10491        '''
10492        self.healthy = healthy if healthy is not None else False
10493        '''
10494         True if the datasource is reachable and the credentials are valid.
10495        '''
10496        self.hostname = hostname if hostname is not None else ''
10497        self.id = id if id is not None else ''
10498        '''
10499         Unique identifier of the Resource.
10500        '''
10501        self.name = name if name is not None else ''
10502        '''
10503         Unique human-readable name of the Resource.
10504        '''
10505        self.override_database = override_database if override_database is not None else False
10506        self.password = password if password is not None else ''
10507        self.port = port if port is not None else 0
10508        self.port_override = port_override if port_override is not None else 0
10509        self.schema = schema if schema is not None else ''
10510        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10511        '''
10512         ID of the secret store containing credentials for this resource, if any.
10513        '''
10514        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10515        '''
10516         Tags is a map of key, value pairs.
10517        '''
10518        self.username = username if username is not None else ''
10519
10520    def __repr__(self):
10521        return '<sdm.SQLServer ' + \
10522            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10523            'database: ' + repr(self.database) + ' ' +\
10524            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10525            'healthy: ' + repr(self.healthy) + ' ' +\
10526            'hostname: ' + repr(self.hostname) + ' ' +\
10527            'id: ' + repr(self.id) + ' ' +\
10528            'name: ' + repr(self.name) + ' ' +\
10529            'override_database: ' + repr(self.override_database) + ' ' +\
10530            'password: ' + repr(self.password) + ' ' +\
10531            'port: ' + repr(self.port) + ' ' +\
10532            'port_override: ' + repr(self.port_override) + ' ' +\
10533            'schema: ' + repr(self.schema) + ' ' +\
10534            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10535            'tags: ' + repr(self.tags) + ' ' +\
10536            'username: ' + repr(self.username) + ' ' +\
10537            '>'
10538
10539    def to_dict(self):
10540        return {
10541            'bind_interface': self.bind_interface,
10542            'database': self.database,
10543            'egress_filter': self.egress_filter,
10544            'healthy': self.healthy,
10545            'hostname': self.hostname,
10546            'id': self.id,
10547            'name': self.name,
10548            'override_database': self.override_database,
10549            'password': self.password,
10550            'port': self.port,
10551            'port_override': self.port_override,
10552            'schema': self.schema,
10553            'secret_store_id': self.secret_store_id,
10554            'tags': self.tags,
10555            'username': self.username,
10556        }
10557
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            bind_interface=d.get('bind_interface'),
10562            database=d.get('database'),
10563            egress_filter=d.get('egress_filter'),
10564            healthy=d.get('healthy'),
10565            hostname=d.get('hostname'),
10566            id=d.get('id'),
10567            name=d.get('name'),
10568            override_database=d.get('override_database'),
10569            password=d.get('password'),
10570            port=d.get('port'),
10571            port_override=d.get('port_override'),
10572            schema=d.get('schema'),
10573            secret_store_id=d.get('secret_store_id'),
10574            tags=d.get('tags'),
10575            username=d.get('username'),
10576        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10465    def __init__(
10466        self,
10467        bind_interface=None,
10468        database=None,
10469        egress_filter=None,
10470        healthy=None,
10471        hostname=None,
10472        id=None,
10473        name=None,
10474        override_database=None,
10475        password=None,
10476        port=None,
10477        port_override=None,
10478        schema=None,
10479        secret_store_id=None,
10480        tags=None,
10481        username=None,
10482    ):
10483        self.bind_interface = bind_interface if bind_interface is not None else ''
10484        '''
10485         Bind interface
10486        '''
10487        self.database = database if database is not None else ''
10488        self.egress_filter = egress_filter if egress_filter is not None else ''
10489        '''
10490         A filter applied to the routing logic to pin datasource to nodes.
10491        '''
10492        self.healthy = healthy if healthy is not None else False
10493        '''
10494         True if the datasource is reachable and the credentials are valid.
10495        '''
10496        self.hostname = hostname if hostname is not None else ''
10497        self.id = id if id is not None else ''
10498        '''
10499         Unique identifier of the Resource.
10500        '''
10501        self.name = name if name is not None else ''
10502        '''
10503         Unique human-readable name of the Resource.
10504        '''
10505        self.override_database = override_database if override_database is not None else False
10506        self.password = password if password is not None else ''
10507        self.port = port if port is not None else 0
10508        self.port_override = port_override if port_override is not None else 0
10509        self.schema = schema if schema is not None else ''
10510        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10511        '''
10512         ID of the secret store containing credentials for this resource, if any.
10513        '''
10514        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10515        '''
10516         Tags is a map of key, value pairs.
10517        '''
10518        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10539    def to_dict(self):
10540        return {
10541            'bind_interface': self.bind_interface,
10542            'database': self.database,
10543            'egress_filter': self.egress_filter,
10544            'healthy': self.healthy,
10545            'hostname': self.hostname,
10546            'id': self.id,
10547            'name': self.name,
10548            'override_database': self.override_database,
10549            'password': self.password,
10550            'port': self.port,
10551            'port_override': self.port_override,
10552            'schema': self.schema,
10553            'secret_store_id': self.secret_store_id,
10554            'tags': self.tags,
10555            'username': self.username,
10556        }
@classmethod
def from_dict(cls, d)
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            bind_interface=d.get('bind_interface'),
10562            database=d.get('database'),
10563            egress_filter=d.get('egress_filter'),
10564            healthy=d.get('healthy'),
10565            hostname=d.get('hostname'),
10566            id=d.get('id'),
10567            name=d.get('name'),
10568            override_database=d.get('override_database'),
10569            password=d.get('password'),
10570            port=d.get('port'),
10571            port_override=d.get('port_override'),
10572            schema=d.get('schema'),
10573            secret_store_id=d.get('secret_store_id'),
10574            tags=d.get('tags'),
10575            username=d.get('username'),
10576        )
class SSH:
10579class SSH:
10580    __slots__ = [
10581        'allow_deprecated_key_exchanges',
10582        'bind_interface',
10583        'egress_filter',
10584        'healthy',
10585        'hostname',
10586        'id',
10587        'key_type',
10588        'name',
10589        'port',
10590        'port_forwarding',
10591        'port_override',
10592        'public_key',
10593        'secret_store_id',
10594        'tags',
10595        'username',
10596    ]
10597
10598    def __init__(
10599        self,
10600        allow_deprecated_key_exchanges=None,
10601        bind_interface=None,
10602        egress_filter=None,
10603        healthy=None,
10604        hostname=None,
10605        id=None,
10606        key_type=None,
10607        name=None,
10608        port=None,
10609        port_forwarding=None,
10610        port_override=None,
10611        public_key=None,
10612        secret_store_id=None,
10613        tags=None,
10614        username=None,
10615    ):
10616        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10617        self.bind_interface = bind_interface if bind_interface is not None else ''
10618        '''
10619         Bind interface
10620        '''
10621        self.egress_filter = egress_filter if egress_filter is not None else ''
10622        '''
10623         A filter applied to the routing logic to pin datasource to nodes.
10624        '''
10625        self.healthy = healthy if healthy is not None else False
10626        '''
10627         True if the datasource is reachable and the credentials are valid.
10628        '''
10629        self.hostname = hostname if hostname is not None else ''
10630        self.id = id if id is not None else ''
10631        '''
10632         Unique identifier of the Resource.
10633        '''
10634        self.key_type = key_type if key_type is not None else ''
10635        self.name = name if name is not None else ''
10636        '''
10637         Unique human-readable name of the Resource.
10638        '''
10639        self.port = port if port is not None else 0
10640        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10641        self.port_override = port_override if port_override is not None else 0
10642        self.public_key = public_key if public_key is not None else ''
10643        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10644        '''
10645         ID of the secret store containing credentials for this resource, if any.
10646        '''
10647        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10648        '''
10649         Tags is a map of key, value pairs.
10650        '''
10651        self.username = username if username is not None else ''
10652
10653    def __repr__(self):
10654        return '<sdm.SSH ' + \
10655            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10656            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10657            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10658            'healthy: ' + repr(self.healthy) + ' ' +\
10659            'hostname: ' + repr(self.hostname) + ' ' +\
10660            'id: ' + repr(self.id) + ' ' +\
10661            'key_type: ' + repr(self.key_type) + ' ' +\
10662            'name: ' + repr(self.name) + ' ' +\
10663            'port: ' + repr(self.port) + ' ' +\
10664            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10665            'port_override: ' + repr(self.port_override) + ' ' +\
10666            'public_key: ' + repr(self.public_key) + ' ' +\
10667            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10668            'tags: ' + repr(self.tags) + ' ' +\
10669            'username: ' + repr(self.username) + ' ' +\
10670            '>'
10671
10672    def to_dict(self):
10673        return {
10674            'allow_deprecated_key_exchanges':
10675            self.allow_deprecated_key_exchanges,
10676            'bind_interface': self.bind_interface,
10677            'egress_filter': self.egress_filter,
10678            'healthy': self.healthy,
10679            'hostname': self.hostname,
10680            'id': self.id,
10681            'key_type': self.key_type,
10682            'name': self.name,
10683            'port': self.port,
10684            'port_forwarding': self.port_forwarding,
10685            'port_override': self.port_override,
10686            'public_key': self.public_key,
10687            'secret_store_id': self.secret_store_id,
10688            'tags': self.tags,
10689            'username': self.username,
10690        }
10691
10692    @classmethod
10693    def from_dict(cls, d):
10694        return cls(
10695            allow_deprecated_key_exchanges=d.get(
10696                'allow_deprecated_key_exchanges'),
10697            bind_interface=d.get('bind_interface'),
10698            egress_filter=d.get('egress_filter'),
10699            healthy=d.get('healthy'),
10700            hostname=d.get('hostname'),
10701            id=d.get('id'),
10702            key_type=d.get('key_type'),
10703            name=d.get('name'),
10704            port=d.get('port'),
10705            port_forwarding=d.get('port_forwarding'),
10706            port_override=d.get('port_override'),
10707            public_key=d.get('public_key'),
10708            secret_store_id=d.get('secret_store_id'),
10709            tags=d.get('tags'),
10710            username=d.get('username'),
10711        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10598    def __init__(
10599        self,
10600        allow_deprecated_key_exchanges=None,
10601        bind_interface=None,
10602        egress_filter=None,
10603        healthy=None,
10604        hostname=None,
10605        id=None,
10606        key_type=None,
10607        name=None,
10608        port=None,
10609        port_forwarding=None,
10610        port_override=None,
10611        public_key=None,
10612        secret_store_id=None,
10613        tags=None,
10614        username=None,
10615    ):
10616        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10617        self.bind_interface = bind_interface if bind_interface is not None else ''
10618        '''
10619         Bind interface
10620        '''
10621        self.egress_filter = egress_filter if egress_filter is not None else ''
10622        '''
10623         A filter applied to the routing logic to pin datasource to nodes.
10624        '''
10625        self.healthy = healthy if healthy is not None else False
10626        '''
10627         True if the datasource is reachable and the credentials are valid.
10628        '''
10629        self.hostname = hostname if hostname is not None else ''
10630        self.id = id if id is not None else ''
10631        '''
10632         Unique identifier of the Resource.
10633        '''
10634        self.key_type = key_type if key_type is not None else ''
10635        self.name = name if name is not None else ''
10636        '''
10637         Unique human-readable name of the Resource.
10638        '''
10639        self.port = port if port is not None else 0
10640        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10641        self.port_override = port_override if port_override is not None else 0
10642        self.public_key = public_key if public_key is not None else ''
10643        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10644        '''
10645         ID of the secret store containing credentials for this resource, if any.
10646        '''
10647        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10648        '''
10649         Tags is a map of key, value pairs.
10650        '''
10651        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10672    def to_dict(self):
10673        return {
10674            'allow_deprecated_key_exchanges':
10675            self.allow_deprecated_key_exchanges,
10676            'bind_interface': self.bind_interface,
10677            'egress_filter': self.egress_filter,
10678            'healthy': self.healthy,
10679            'hostname': self.hostname,
10680            'id': self.id,
10681            'key_type': self.key_type,
10682            'name': self.name,
10683            'port': self.port,
10684            'port_forwarding': self.port_forwarding,
10685            'port_override': self.port_override,
10686            'public_key': self.public_key,
10687            'secret_store_id': self.secret_store_id,
10688            'tags': self.tags,
10689            'username': self.username,
10690        }
@classmethod
def from_dict(cls, d)
10692    @classmethod
10693    def from_dict(cls, d):
10694        return cls(
10695            allow_deprecated_key_exchanges=d.get(
10696                'allow_deprecated_key_exchanges'),
10697            bind_interface=d.get('bind_interface'),
10698            egress_filter=d.get('egress_filter'),
10699            healthy=d.get('healthy'),
10700            hostname=d.get('hostname'),
10701            id=d.get('id'),
10702            key_type=d.get('key_type'),
10703            name=d.get('name'),
10704            port=d.get('port'),
10705            port_forwarding=d.get('port_forwarding'),
10706            port_override=d.get('port_override'),
10707            public_key=d.get('public_key'),
10708            secret_store_id=d.get('secret_store_id'),
10709            tags=d.get('tags'),
10710            username=d.get('username'),
10711        )
class SSHCert:
10714class SSHCert:
10715    __slots__ = [
10716        'allow_deprecated_key_exchanges',
10717        'bind_interface',
10718        'egress_filter',
10719        'healthy',
10720        'hostname',
10721        'id',
10722        'key_type',
10723        'name',
10724        'port',
10725        'port_forwarding',
10726        'port_override',
10727        'remote_identity_group_id',
10728        'remote_identity_healthcheck_username',
10729        'secret_store_id',
10730        'tags',
10731        'username',
10732    ]
10733
10734    def __init__(
10735        self,
10736        allow_deprecated_key_exchanges=None,
10737        bind_interface=None,
10738        egress_filter=None,
10739        healthy=None,
10740        hostname=None,
10741        id=None,
10742        key_type=None,
10743        name=None,
10744        port=None,
10745        port_forwarding=None,
10746        port_override=None,
10747        remote_identity_group_id=None,
10748        remote_identity_healthcheck_username=None,
10749        secret_store_id=None,
10750        tags=None,
10751        username=None,
10752    ):
10753        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10754        self.bind_interface = bind_interface if bind_interface is not None else ''
10755        '''
10756         Bind interface
10757        '''
10758        self.egress_filter = egress_filter if egress_filter is not None else ''
10759        '''
10760         A filter applied to the routing logic to pin datasource to nodes.
10761        '''
10762        self.healthy = healthy if healthy is not None else False
10763        '''
10764         True if the datasource is reachable and the credentials are valid.
10765        '''
10766        self.hostname = hostname if hostname is not None else ''
10767        self.id = id if id is not None else ''
10768        '''
10769         Unique identifier of the Resource.
10770        '''
10771        self.key_type = key_type if key_type is not None else ''
10772        self.name = name if name is not None else ''
10773        '''
10774         Unique human-readable name of the Resource.
10775        '''
10776        self.port = port if port is not None else 0
10777        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10778        self.port_override = port_override if port_override is not None else 0
10779        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10780        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10782        '''
10783         ID of the secret store containing credentials for this resource, if any.
10784        '''
10785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10786        '''
10787         Tags is a map of key, value pairs.
10788        '''
10789        self.username = username if username is not None else ''
10790
10791    def __repr__(self):
10792        return '<sdm.SSHCert ' + \
10793            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10794            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10795            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10796            'healthy: ' + repr(self.healthy) + ' ' +\
10797            'hostname: ' + repr(self.hostname) + ' ' +\
10798            'id: ' + repr(self.id) + ' ' +\
10799            'key_type: ' + repr(self.key_type) + ' ' +\
10800            'name: ' + repr(self.name) + ' ' +\
10801            'port: ' + repr(self.port) + ' ' +\
10802            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10803            'port_override: ' + repr(self.port_override) + ' ' +\
10804            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10805            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10806            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10807            'tags: ' + repr(self.tags) + ' ' +\
10808            'username: ' + repr(self.username) + ' ' +\
10809            '>'
10810
10811    def to_dict(self):
10812        return {
10813            'allow_deprecated_key_exchanges':
10814            self.allow_deprecated_key_exchanges,
10815            'bind_interface': self.bind_interface,
10816            'egress_filter': self.egress_filter,
10817            'healthy': self.healthy,
10818            'hostname': self.hostname,
10819            'id': self.id,
10820            'key_type': self.key_type,
10821            'name': self.name,
10822            'port': self.port,
10823            'port_forwarding': self.port_forwarding,
10824            'port_override': self.port_override,
10825            'remote_identity_group_id': self.remote_identity_group_id,
10826            'remote_identity_healthcheck_username':
10827            self.remote_identity_healthcheck_username,
10828            'secret_store_id': self.secret_store_id,
10829            'tags': self.tags,
10830            'username': self.username,
10831        }
10832
10833    @classmethod
10834    def from_dict(cls, d):
10835        return cls(
10836            allow_deprecated_key_exchanges=d.get(
10837                'allow_deprecated_key_exchanges'),
10838            bind_interface=d.get('bind_interface'),
10839            egress_filter=d.get('egress_filter'),
10840            healthy=d.get('healthy'),
10841            hostname=d.get('hostname'),
10842            id=d.get('id'),
10843            key_type=d.get('key_type'),
10844            name=d.get('name'),
10845            port=d.get('port'),
10846            port_forwarding=d.get('port_forwarding'),
10847            port_override=d.get('port_override'),
10848            remote_identity_group_id=d.get('remote_identity_group_id'),
10849            remote_identity_healthcheck_username=d.get(
10850                'remote_identity_healthcheck_username'),
10851            secret_store_id=d.get('secret_store_id'),
10852            tags=d.get('tags'),
10853            username=d.get('username'),
10854        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10734    def __init__(
10735        self,
10736        allow_deprecated_key_exchanges=None,
10737        bind_interface=None,
10738        egress_filter=None,
10739        healthy=None,
10740        hostname=None,
10741        id=None,
10742        key_type=None,
10743        name=None,
10744        port=None,
10745        port_forwarding=None,
10746        port_override=None,
10747        remote_identity_group_id=None,
10748        remote_identity_healthcheck_username=None,
10749        secret_store_id=None,
10750        tags=None,
10751        username=None,
10752    ):
10753        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10754        self.bind_interface = bind_interface if bind_interface is not None else ''
10755        '''
10756         Bind interface
10757        '''
10758        self.egress_filter = egress_filter if egress_filter is not None else ''
10759        '''
10760         A filter applied to the routing logic to pin datasource to nodes.
10761        '''
10762        self.healthy = healthy if healthy is not None else False
10763        '''
10764         True if the datasource is reachable and the credentials are valid.
10765        '''
10766        self.hostname = hostname if hostname is not None else ''
10767        self.id = id if id is not None else ''
10768        '''
10769         Unique identifier of the Resource.
10770        '''
10771        self.key_type = key_type if key_type is not None else ''
10772        self.name = name if name is not None else ''
10773        '''
10774         Unique human-readable name of the Resource.
10775        '''
10776        self.port = port if port is not None else 0
10777        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10778        self.port_override = port_override if port_override is not None else 0
10779        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10780        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10782        '''
10783         ID of the secret store containing credentials for this resource, if any.
10784        '''
10785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10786        '''
10787         Tags is a map of key, value pairs.
10788        '''
10789        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10811    def to_dict(self):
10812        return {
10813            'allow_deprecated_key_exchanges':
10814            self.allow_deprecated_key_exchanges,
10815            'bind_interface': self.bind_interface,
10816            'egress_filter': self.egress_filter,
10817            'healthy': self.healthy,
10818            'hostname': self.hostname,
10819            'id': self.id,
10820            'key_type': self.key_type,
10821            'name': self.name,
10822            'port': self.port,
10823            'port_forwarding': self.port_forwarding,
10824            'port_override': self.port_override,
10825            'remote_identity_group_id': self.remote_identity_group_id,
10826            'remote_identity_healthcheck_username':
10827            self.remote_identity_healthcheck_username,
10828            'secret_store_id': self.secret_store_id,
10829            'tags': self.tags,
10830            'username': self.username,
10831        }
@classmethod
def from_dict(cls, d)
10833    @classmethod
10834    def from_dict(cls, d):
10835        return cls(
10836            allow_deprecated_key_exchanges=d.get(
10837                'allow_deprecated_key_exchanges'),
10838            bind_interface=d.get('bind_interface'),
10839            egress_filter=d.get('egress_filter'),
10840            healthy=d.get('healthy'),
10841            hostname=d.get('hostname'),
10842            id=d.get('id'),
10843            key_type=d.get('key_type'),
10844            name=d.get('name'),
10845            port=d.get('port'),
10846            port_forwarding=d.get('port_forwarding'),
10847            port_override=d.get('port_override'),
10848            remote_identity_group_id=d.get('remote_identity_group_id'),
10849            remote_identity_healthcheck_username=d.get(
10850                'remote_identity_healthcheck_username'),
10851            secret_store_id=d.get('secret_store_id'),
10852            tags=d.get('tags'),
10853            username=d.get('username'),
10854        )
class SSHCustomerKey:
10857class SSHCustomerKey:
10858    __slots__ = [
10859        'allow_deprecated_key_exchanges',
10860        'bind_interface',
10861        'egress_filter',
10862        'healthy',
10863        'hostname',
10864        'id',
10865        'name',
10866        'port',
10867        'port_forwarding',
10868        'port_override',
10869        'private_key',
10870        'secret_store_id',
10871        'tags',
10872        'username',
10873    ]
10874
10875    def __init__(
10876        self,
10877        allow_deprecated_key_exchanges=None,
10878        bind_interface=None,
10879        egress_filter=None,
10880        healthy=None,
10881        hostname=None,
10882        id=None,
10883        name=None,
10884        port=None,
10885        port_forwarding=None,
10886        port_override=None,
10887        private_key=None,
10888        secret_store_id=None,
10889        tags=None,
10890        username=None,
10891    ):
10892        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10893        self.bind_interface = bind_interface if bind_interface is not None else ''
10894        '''
10895         Bind interface
10896        '''
10897        self.egress_filter = egress_filter if egress_filter is not None else ''
10898        '''
10899         A filter applied to the routing logic to pin datasource to nodes.
10900        '''
10901        self.healthy = healthy if healthy is not None else False
10902        '''
10903         True if the datasource is reachable and the credentials are valid.
10904        '''
10905        self.hostname = hostname if hostname is not None else ''
10906        self.id = id if id is not None else ''
10907        '''
10908         Unique identifier of the Resource.
10909        '''
10910        self.name = name if name is not None else ''
10911        '''
10912         Unique human-readable name of the Resource.
10913        '''
10914        self.port = port if port is not None else 0
10915        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10916        self.port_override = port_override if port_override is not None else 0
10917        self.private_key = private_key if private_key is not None else ''
10918        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10919        '''
10920         ID of the secret store containing credentials for this resource, if any.
10921        '''
10922        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10923        '''
10924         Tags is a map of key, value pairs.
10925        '''
10926        self.username = username if username is not None else ''
10927
10928    def __repr__(self):
10929        return '<sdm.SSHCustomerKey ' + \
10930            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10931            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10932            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10933            'healthy: ' + repr(self.healthy) + ' ' +\
10934            'hostname: ' + repr(self.hostname) + ' ' +\
10935            'id: ' + repr(self.id) + ' ' +\
10936            'name: ' + repr(self.name) + ' ' +\
10937            'port: ' + repr(self.port) + ' ' +\
10938            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10939            'port_override: ' + repr(self.port_override) + ' ' +\
10940            'private_key: ' + repr(self.private_key) + ' ' +\
10941            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10942            'tags: ' + repr(self.tags) + ' ' +\
10943            'username: ' + repr(self.username) + ' ' +\
10944            '>'
10945
10946    def to_dict(self):
10947        return {
10948            'allow_deprecated_key_exchanges':
10949            self.allow_deprecated_key_exchanges,
10950            'bind_interface': self.bind_interface,
10951            'egress_filter': self.egress_filter,
10952            'healthy': self.healthy,
10953            'hostname': self.hostname,
10954            'id': self.id,
10955            'name': self.name,
10956            'port': self.port,
10957            'port_forwarding': self.port_forwarding,
10958            'port_override': self.port_override,
10959            'private_key': self.private_key,
10960            'secret_store_id': self.secret_store_id,
10961            'tags': self.tags,
10962            'username': self.username,
10963        }
10964
10965    @classmethod
10966    def from_dict(cls, d):
10967        return cls(
10968            allow_deprecated_key_exchanges=d.get(
10969                'allow_deprecated_key_exchanges'),
10970            bind_interface=d.get('bind_interface'),
10971            egress_filter=d.get('egress_filter'),
10972            healthy=d.get('healthy'),
10973            hostname=d.get('hostname'),
10974            id=d.get('id'),
10975            name=d.get('name'),
10976            port=d.get('port'),
10977            port_forwarding=d.get('port_forwarding'),
10978            port_override=d.get('port_override'),
10979            private_key=d.get('private_key'),
10980            secret_store_id=d.get('secret_store_id'),
10981            tags=d.get('tags'),
10982            username=d.get('username'),
10983        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
10875    def __init__(
10876        self,
10877        allow_deprecated_key_exchanges=None,
10878        bind_interface=None,
10879        egress_filter=None,
10880        healthy=None,
10881        hostname=None,
10882        id=None,
10883        name=None,
10884        port=None,
10885        port_forwarding=None,
10886        port_override=None,
10887        private_key=None,
10888        secret_store_id=None,
10889        tags=None,
10890        username=None,
10891    ):
10892        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10893        self.bind_interface = bind_interface if bind_interface is not None else ''
10894        '''
10895         Bind interface
10896        '''
10897        self.egress_filter = egress_filter if egress_filter is not None else ''
10898        '''
10899         A filter applied to the routing logic to pin datasource to nodes.
10900        '''
10901        self.healthy = healthy if healthy is not None else False
10902        '''
10903         True if the datasource is reachable and the credentials are valid.
10904        '''
10905        self.hostname = hostname if hostname is not None else ''
10906        self.id = id if id is not None else ''
10907        '''
10908         Unique identifier of the Resource.
10909        '''
10910        self.name = name if name is not None else ''
10911        '''
10912         Unique human-readable name of the Resource.
10913        '''
10914        self.port = port if port is not None else 0
10915        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10916        self.port_override = port_override if port_override is not None else 0
10917        self.private_key = private_key if private_key is not None else ''
10918        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10919        '''
10920         ID of the secret store containing credentials for this resource, if any.
10921        '''
10922        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10923        '''
10924         Tags is a map of key, value pairs.
10925        '''
10926        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10946    def to_dict(self):
10947        return {
10948            'allow_deprecated_key_exchanges':
10949            self.allow_deprecated_key_exchanges,
10950            'bind_interface': self.bind_interface,
10951            'egress_filter': self.egress_filter,
10952            'healthy': self.healthy,
10953            'hostname': self.hostname,
10954            'id': self.id,
10955            'name': self.name,
10956            'port': self.port,
10957            'port_forwarding': self.port_forwarding,
10958            'port_override': self.port_override,
10959            'private_key': self.private_key,
10960            'secret_store_id': self.secret_store_id,
10961            'tags': self.tags,
10962            'username': self.username,
10963        }
@classmethod
def from_dict(cls, d)
10965    @classmethod
10966    def from_dict(cls, d):
10967        return cls(
10968            allow_deprecated_key_exchanges=d.get(
10969                'allow_deprecated_key_exchanges'),
10970            bind_interface=d.get('bind_interface'),
10971            egress_filter=d.get('egress_filter'),
10972            healthy=d.get('healthy'),
10973            hostname=d.get('hostname'),
10974            id=d.get('id'),
10975            name=d.get('name'),
10976            port=d.get('port'),
10977            port_forwarding=d.get('port_forwarding'),
10978            port_override=d.get('port_override'),
10979            private_key=d.get('private_key'),
10980            secret_store_id=d.get('secret_store_id'),
10981            tags=d.get('tags'),
10982            username=d.get('username'),
10983        )
class SecretStoreCreateResponse:
10986class SecretStoreCreateResponse:
10987    '''
10988         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10989    '''
10990    __slots__ = [
10991        'meta',
10992        'rate_limit',
10993        'secret_store',
10994    ]
10995
10996    def __init__(
10997        self,
10998        meta=None,
10999        rate_limit=None,
11000        secret_store=None,
11001    ):
11002        self.meta = meta if meta is not None else None
11003        '''
11004         Reserved for future use.
11005        '''
11006        self.rate_limit = rate_limit if rate_limit is not None else None
11007        '''
11008         Rate limit information.
11009        '''
11010        self.secret_store = secret_store if secret_store is not None else None
11011        '''
11012         The created SecretStore.
11013        '''
11014
11015    def __repr__(self):
11016        return '<sdm.SecretStoreCreateResponse ' + \
11017            'meta: ' + repr(self.meta) + ' ' +\
11018            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11019            'secret_store: ' + repr(self.secret_store) + ' ' +\
11020            '>'
11021
11022    def to_dict(self):
11023        return {
11024            'meta': self.meta,
11025            'rate_limit': self.rate_limit,
11026            'secret_store': self.secret_store,
11027        }
11028
11029    @classmethod
11030    def from_dict(cls, d):
11031        return cls(
11032            meta=d.get('meta'),
11033            rate_limit=d.get('rate_limit'),
11034            secret_store=d.get('secret_store'),
11035        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
10996    def __init__(
10997        self,
10998        meta=None,
10999        rate_limit=None,
11000        secret_store=None,
11001    ):
11002        self.meta = meta if meta is not None else None
11003        '''
11004         Reserved for future use.
11005        '''
11006        self.rate_limit = rate_limit if rate_limit is not None else None
11007        '''
11008         Rate limit information.
11009        '''
11010        self.secret_store = secret_store if secret_store is not None else None
11011        '''
11012         The created SecretStore.
11013        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11022    def to_dict(self):
11023        return {
11024            'meta': self.meta,
11025            'rate_limit': self.rate_limit,
11026            'secret_store': self.secret_store,
11027        }
@classmethod
def from_dict(cls, d)
11029    @classmethod
11030    def from_dict(cls, d):
11031        return cls(
11032            meta=d.get('meta'),
11033            rate_limit=d.get('rate_limit'),
11034            secret_store=d.get('secret_store'),
11035        )
class SecretStoreDeleteResponse:
11038class SecretStoreDeleteResponse:
11039    '''
11040         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11041    '''
11042    __slots__ = [
11043        'meta',
11044        'rate_limit',
11045    ]
11046
11047    def __init__(
11048        self,
11049        meta=None,
11050        rate_limit=None,
11051    ):
11052        self.meta = meta if meta is not None else None
11053        '''
11054         Reserved for future use.
11055        '''
11056        self.rate_limit = rate_limit if rate_limit is not None else None
11057        '''
11058         Rate limit information.
11059        '''
11060
11061    def __repr__(self):
11062        return '<sdm.SecretStoreDeleteResponse ' + \
11063            'meta: ' + repr(self.meta) + ' ' +\
11064            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11065            '>'
11066
11067    def to_dict(self):
11068        return {
11069            'meta': self.meta,
11070            'rate_limit': self.rate_limit,
11071        }
11072
11073    @classmethod
11074    def from_dict(cls, d):
11075        return cls(
11076            meta=d.get('meta'),
11077            rate_limit=d.get('rate_limit'),
11078        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11047    def __init__(
11048        self,
11049        meta=None,
11050        rate_limit=None,
11051    ):
11052        self.meta = meta if meta is not None else None
11053        '''
11054         Reserved for future use.
11055        '''
11056        self.rate_limit = rate_limit if rate_limit is not None else None
11057        '''
11058         Rate limit information.
11059        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11067    def to_dict(self):
11068        return {
11069            'meta': self.meta,
11070            'rate_limit': self.rate_limit,
11071        }
@classmethod
def from_dict(cls, d)
11073    @classmethod
11074    def from_dict(cls, d):
11075        return cls(
11076            meta=d.get('meta'),
11077            rate_limit=d.get('rate_limit'),
11078        )
class SecretStoreGetResponse:
11081class SecretStoreGetResponse:
11082    '''
11083         SecretStoreGetResponse returns a requested SecretStore.
11084    '''
11085    __slots__ = [
11086        'meta',
11087        'rate_limit',
11088        'secret_store',
11089    ]
11090
11091    def __init__(
11092        self,
11093        meta=None,
11094        rate_limit=None,
11095        secret_store=None,
11096    ):
11097        self.meta = meta if meta is not None else None
11098        '''
11099         Reserved for future use.
11100        '''
11101        self.rate_limit = rate_limit if rate_limit is not None else None
11102        '''
11103         Rate limit information.
11104        '''
11105        self.secret_store = secret_store if secret_store is not None else None
11106        '''
11107         The requested SecretStore.
11108        '''
11109
11110    def __repr__(self):
11111        return '<sdm.SecretStoreGetResponse ' + \
11112            'meta: ' + repr(self.meta) + ' ' +\
11113            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11114            'secret_store: ' + repr(self.secret_store) + ' ' +\
11115            '>'
11116
11117    def to_dict(self):
11118        return {
11119            'meta': self.meta,
11120            'rate_limit': self.rate_limit,
11121            'secret_store': self.secret_store,
11122        }
11123
11124    @classmethod
11125    def from_dict(cls, d):
11126        return cls(
11127            meta=d.get('meta'),
11128            rate_limit=d.get('rate_limit'),
11129            secret_store=d.get('secret_store'),
11130        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
11091    def __init__(
11092        self,
11093        meta=None,
11094        rate_limit=None,
11095        secret_store=None,
11096    ):
11097        self.meta = meta if meta is not None else None
11098        '''
11099         Reserved for future use.
11100        '''
11101        self.rate_limit = rate_limit if rate_limit is not None else None
11102        '''
11103         Rate limit information.
11104        '''
11105        self.secret_store = secret_store if secret_store is not None else None
11106        '''
11107         The requested SecretStore.
11108        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
11117    def to_dict(self):
11118        return {
11119            'meta': self.meta,
11120            'rate_limit': self.rate_limit,
11121            'secret_store': self.secret_store,
11122        }
@classmethod
def from_dict(cls, d)
11124    @classmethod
11125    def from_dict(cls, d):
11126        return cls(
11127            meta=d.get('meta'),
11128            rate_limit=d.get('rate_limit'),
11129            secret_store=d.get('secret_store'),
11130        )
class SecretStoreUpdateResponse:
11133class SecretStoreUpdateResponse:
11134    '''
11135         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11136     a SecretStoreUpdateRequest.
11137    '''
11138    __slots__ = [
11139        'meta',
11140        'rate_limit',
11141        'secret_store',
11142    ]
11143
11144    def __init__(
11145        self,
11146        meta=None,
11147        rate_limit=None,
11148        secret_store=None,
11149    ):
11150        self.meta = meta if meta is not None else None
11151        '''
11152         Reserved for future use.
11153        '''
11154        self.rate_limit = rate_limit if rate_limit is not None else None
11155        '''
11156         Rate limit information.
11157        '''
11158        self.secret_store = secret_store if secret_store is not None else None
11159        '''
11160         The updated SecretStore.
11161        '''
11162
11163    def __repr__(self):
11164        return '<sdm.SecretStoreUpdateResponse ' + \
11165            'meta: ' + repr(self.meta) + ' ' +\
11166            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11167            'secret_store: ' + repr(self.secret_store) + ' ' +\
11168            '>'
11169
11170    def to_dict(self):
11171        return {
11172            'meta': self.meta,
11173            'rate_limit': self.rate_limit,
11174            'secret_store': self.secret_store,
11175        }
11176
11177    @classmethod
11178    def from_dict(cls, d):
11179        return cls(
11180            meta=d.get('meta'),
11181            rate_limit=d.get('rate_limit'),
11182            secret_store=d.get('secret_store'),
11183        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
11144    def __init__(
11145        self,
11146        meta=None,
11147        rate_limit=None,
11148        secret_store=None,
11149    ):
11150        self.meta = meta if meta is not None else None
11151        '''
11152         Reserved for future use.
11153        '''
11154        self.rate_limit = rate_limit if rate_limit is not None else None
11155        '''
11156         Rate limit information.
11157        '''
11158        self.secret_store = secret_store if secret_store is not None else None
11159        '''
11160         The updated SecretStore.
11161        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
11170    def to_dict(self):
11171        return {
11172            'meta': self.meta,
11173            'rate_limit': self.rate_limit,
11174            'secret_store': self.secret_store,
11175        }
@classmethod
def from_dict(cls, d)
11177    @classmethod
11178    def from_dict(cls, d):
11179        return cls(
11180            meta=d.get('meta'),
11181            rate_limit=d.get('rate_limit'),
11182            secret_store=d.get('secret_store'),
11183        )
class Service:
11186class Service:
11187    '''
11188         A Service is a service account that can connect to resources they are granted
11189     directly, or granted via roles. Services are typically automated jobs.
11190    '''
11191    __slots__ = [
11192        'id',
11193        'name',
11194        'suspended',
11195        'tags',
11196    ]
11197
11198    def __init__(
11199        self,
11200        id=None,
11201        name=None,
11202        suspended=None,
11203        tags=None,
11204    ):
11205        self.id = id if id is not None else ''
11206        '''
11207         Unique identifier of the Service.
11208        '''
11209        self.name = name if name is not None else ''
11210        '''
11211         Unique human-readable name of the Service.
11212        '''
11213        self.suspended = suspended if suspended is not None else False
11214        '''
11215         The Service's suspended state.
11216        '''
11217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11218        '''
11219         Tags is a map of key, value pairs.
11220        '''
11221
11222    def __repr__(self):
11223        return '<sdm.Service ' + \
11224            'id: ' + repr(self.id) + ' ' +\
11225            'name: ' + repr(self.name) + ' ' +\
11226            'suspended: ' + repr(self.suspended) + ' ' +\
11227            'tags: ' + repr(self.tags) + ' ' +\
11228            '>'
11229
11230    def to_dict(self):
11231        return {
11232            'id': self.id,
11233            'name': self.name,
11234            'suspended': self.suspended,
11235            'tags': self.tags,
11236        }
11237
11238    @classmethod
11239    def from_dict(cls, d):
11240        return cls(
11241            id=d.get('id'),
11242            name=d.get('name'),
11243            suspended=d.get('suspended'),
11244            tags=d.get('tags'),
11245        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
11198    def __init__(
11199        self,
11200        id=None,
11201        name=None,
11202        suspended=None,
11203        tags=None,
11204    ):
11205        self.id = id if id is not None else ''
11206        '''
11207         Unique identifier of the Service.
11208        '''
11209        self.name = name if name is not None else ''
11210        '''
11211         Unique human-readable name of the Service.
11212        '''
11213        self.suspended = suspended if suspended is not None else False
11214        '''
11215         The Service's suspended state.
11216        '''
11217        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11218        '''
11219         Tags is a map of key, value pairs.
11220        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11230    def to_dict(self):
11231        return {
11232            'id': self.id,
11233            'name': self.name,
11234            'suspended': self.suspended,
11235            'tags': self.tags,
11236        }
@classmethod
def from_dict(cls, d)
11238    @classmethod
11239    def from_dict(cls, d):
11240        return cls(
11241            id=d.get('id'),
11242            name=d.get('name'),
11243            suspended=d.get('suspended'),
11244            tags=d.get('tags'),
11245        )
class SingleStore:
11248class SingleStore:
11249    __slots__ = [
11250        'bind_interface',
11251        'database',
11252        'egress_filter',
11253        'healthy',
11254        'hostname',
11255        'id',
11256        'name',
11257        'password',
11258        'port',
11259        'port_override',
11260        'secret_store_id',
11261        'tags',
11262        'username',
11263    ]
11264
11265    def __init__(
11266        self,
11267        bind_interface=None,
11268        database=None,
11269        egress_filter=None,
11270        healthy=None,
11271        hostname=None,
11272        id=None,
11273        name=None,
11274        password=None,
11275        port=None,
11276        port_override=None,
11277        secret_store_id=None,
11278        tags=None,
11279        username=None,
11280    ):
11281        self.bind_interface = bind_interface if bind_interface is not None else ''
11282        '''
11283         Bind interface
11284        '''
11285        self.database = database if database is not None else ''
11286        self.egress_filter = egress_filter if egress_filter is not None else ''
11287        '''
11288         A filter applied to the routing logic to pin datasource to nodes.
11289        '''
11290        self.healthy = healthy if healthy is not None else False
11291        '''
11292         True if the datasource is reachable and the credentials are valid.
11293        '''
11294        self.hostname = hostname if hostname is not None else ''
11295        self.id = id if id is not None else ''
11296        '''
11297         Unique identifier of the Resource.
11298        '''
11299        self.name = name if name is not None else ''
11300        '''
11301         Unique human-readable name of the Resource.
11302        '''
11303        self.password = password if password is not None else ''
11304        self.port = port if port is not None else 0
11305        self.port_override = port_override if port_override is not None else 0
11306        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11307        '''
11308         ID of the secret store containing credentials for this resource, if any.
11309        '''
11310        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11311        '''
11312         Tags is a map of key, value pairs.
11313        '''
11314        self.username = username if username is not None else ''
11315
11316    def __repr__(self):
11317        return '<sdm.SingleStore ' + \
11318            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11319            'database: ' + repr(self.database) + ' ' +\
11320            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11321            'healthy: ' + repr(self.healthy) + ' ' +\
11322            'hostname: ' + repr(self.hostname) + ' ' +\
11323            'id: ' + repr(self.id) + ' ' +\
11324            'name: ' + repr(self.name) + ' ' +\
11325            'password: ' + repr(self.password) + ' ' +\
11326            'port: ' + repr(self.port) + ' ' +\
11327            'port_override: ' + repr(self.port_override) + ' ' +\
11328            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11329            'tags: ' + repr(self.tags) + ' ' +\
11330            'username: ' + repr(self.username) + ' ' +\
11331            '>'
11332
11333    def to_dict(self):
11334        return {
11335            'bind_interface': self.bind_interface,
11336            'database': self.database,
11337            'egress_filter': self.egress_filter,
11338            'healthy': self.healthy,
11339            'hostname': self.hostname,
11340            'id': self.id,
11341            'name': self.name,
11342            'password': self.password,
11343            'port': self.port,
11344            'port_override': self.port_override,
11345            'secret_store_id': self.secret_store_id,
11346            'tags': self.tags,
11347            'username': self.username,
11348        }
11349
11350    @classmethod
11351    def from_dict(cls, d):
11352        return cls(
11353            bind_interface=d.get('bind_interface'),
11354            database=d.get('database'),
11355            egress_filter=d.get('egress_filter'),
11356            healthy=d.get('healthy'),
11357            hostname=d.get('hostname'),
11358            id=d.get('id'),
11359            name=d.get('name'),
11360            password=d.get('password'),
11361            port=d.get('port'),
11362            port_override=d.get('port_override'),
11363            secret_store_id=d.get('secret_store_id'),
11364            tags=d.get('tags'),
11365            username=d.get('username'),
11366        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11265    def __init__(
11266        self,
11267        bind_interface=None,
11268        database=None,
11269        egress_filter=None,
11270        healthy=None,
11271        hostname=None,
11272        id=None,
11273        name=None,
11274        password=None,
11275        port=None,
11276        port_override=None,
11277        secret_store_id=None,
11278        tags=None,
11279        username=None,
11280    ):
11281        self.bind_interface = bind_interface if bind_interface is not None else ''
11282        '''
11283         Bind interface
11284        '''
11285        self.database = database if database is not None else ''
11286        self.egress_filter = egress_filter if egress_filter is not None else ''
11287        '''
11288         A filter applied to the routing logic to pin datasource to nodes.
11289        '''
11290        self.healthy = healthy if healthy is not None else False
11291        '''
11292         True if the datasource is reachable and the credentials are valid.
11293        '''
11294        self.hostname = hostname if hostname is not None else ''
11295        self.id = id if id is not None else ''
11296        '''
11297         Unique identifier of the Resource.
11298        '''
11299        self.name = name if name is not None else ''
11300        '''
11301         Unique human-readable name of the Resource.
11302        '''
11303        self.password = password if password is not None else ''
11304        self.port = port if port is not None else 0
11305        self.port_override = port_override if port_override is not None else 0
11306        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11307        '''
11308         ID of the secret store containing credentials for this resource, if any.
11309        '''
11310        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11311        '''
11312         Tags is a map of key, value pairs.
11313        '''
11314        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11333    def to_dict(self):
11334        return {
11335            'bind_interface': self.bind_interface,
11336            'database': self.database,
11337            'egress_filter': self.egress_filter,
11338            'healthy': self.healthy,
11339            'hostname': self.hostname,
11340            'id': self.id,
11341            'name': self.name,
11342            'password': self.password,
11343            'port': self.port,
11344            'port_override': self.port_override,
11345            'secret_store_id': self.secret_store_id,
11346            'tags': self.tags,
11347            'username': self.username,
11348        }
@classmethod
def from_dict(cls, d)
11350    @classmethod
11351    def from_dict(cls, d):
11352        return cls(
11353            bind_interface=d.get('bind_interface'),
11354            database=d.get('database'),
11355            egress_filter=d.get('egress_filter'),
11356            healthy=d.get('healthy'),
11357            hostname=d.get('hostname'),
11358            id=d.get('id'),
11359            name=d.get('name'),
11360            password=d.get('password'),
11361            port=d.get('port'),
11362            port_override=d.get('port_override'),
11363            secret_store_id=d.get('secret_store_id'),
11364            tags=d.get('tags'),
11365            username=d.get('username'),
11366        )
class Snowflake:
11369class Snowflake:
11370    __slots__ = [
11371        'bind_interface',
11372        'database',
11373        'egress_filter',
11374        'healthy',
11375        'hostname',
11376        'id',
11377        'name',
11378        'password',
11379        'port_override',
11380        'schema',
11381        'secret_store_id',
11382        'tags',
11383        'username',
11384    ]
11385
11386    def __init__(
11387        self,
11388        bind_interface=None,
11389        database=None,
11390        egress_filter=None,
11391        healthy=None,
11392        hostname=None,
11393        id=None,
11394        name=None,
11395        password=None,
11396        port_override=None,
11397        schema=None,
11398        secret_store_id=None,
11399        tags=None,
11400        username=None,
11401    ):
11402        self.bind_interface = bind_interface if bind_interface is not None else ''
11403        '''
11404         Bind interface
11405        '''
11406        self.database = database if database is not None else ''
11407        self.egress_filter = egress_filter if egress_filter is not None else ''
11408        '''
11409         A filter applied to the routing logic to pin datasource to nodes.
11410        '''
11411        self.healthy = healthy if healthy is not None else False
11412        '''
11413         True if the datasource is reachable and the credentials are valid.
11414        '''
11415        self.hostname = hostname if hostname is not None else ''
11416        self.id = id if id is not None else ''
11417        '''
11418         Unique identifier of the Resource.
11419        '''
11420        self.name = name if name is not None else ''
11421        '''
11422         Unique human-readable name of the Resource.
11423        '''
11424        self.password = password if password is not None else ''
11425        self.port_override = port_override if port_override is not None else 0
11426        self.schema = schema if schema is not None else ''
11427        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11428        '''
11429         ID of the secret store containing credentials for this resource, if any.
11430        '''
11431        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11432        '''
11433         Tags is a map of key, value pairs.
11434        '''
11435        self.username = username if username is not None else ''
11436
11437    def __repr__(self):
11438        return '<sdm.Snowflake ' + \
11439            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11440            'database: ' + repr(self.database) + ' ' +\
11441            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11442            'healthy: ' + repr(self.healthy) + ' ' +\
11443            'hostname: ' + repr(self.hostname) + ' ' +\
11444            'id: ' + repr(self.id) + ' ' +\
11445            'name: ' + repr(self.name) + ' ' +\
11446            'password: ' + repr(self.password) + ' ' +\
11447            'port_override: ' + repr(self.port_override) + ' ' +\
11448            'schema: ' + repr(self.schema) + ' ' +\
11449            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11450            'tags: ' + repr(self.tags) + ' ' +\
11451            'username: ' + repr(self.username) + ' ' +\
11452            '>'
11453
11454    def to_dict(self):
11455        return {
11456            'bind_interface': self.bind_interface,
11457            'database': self.database,
11458            'egress_filter': self.egress_filter,
11459            'healthy': self.healthy,
11460            'hostname': self.hostname,
11461            'id': self.id,
11462            'name': self.name,
11463            'password': self.password,
11464            'port_override': self.port_override,
11465            'schema': self.schema,
11466            'secret_store_id': self.secret_store_id,
11467            'tags': self.tags,
11468            'username': self.username,
11469        }
11470
11471    @classmethod
11472    def from_dict(cls, d):
11473        return cls(
11474            bind_interface=d.get('bind_interface'),
11475            database=d.get('database'),
11476            egress_filter=d.get('egress_filter'),
11477            healthy=d.get('healthy'),
11478            hostname=d.get('hostname'),
11479            id=d.get('id'),
11480            name=d.get('name'),
11481            password=d.get('password'),
11482            port_override=d.get('port_override'),
11483            schema=d.get('schema'),
11484            secret_store_id=d.get('secret_store_id'),
11485            tags=d.get('tags'),
11486            username=d.get('username'),
11487        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11386    def __init__(
11387        self,
11388        bind_interface=None,
11389        database=None,
11390        egress_filter=None,
11391        healthy=None,
11392        hostname=None,
11393        id=None,
11394        name=None,
11395        password=None,
11396        port_override=None,
11397        schema=None,
11398        secret_store_id=None,
11399        tags=None,
11400        username=None,
11401    ):
11402        self.bind_interface = bind_interface if bind_interface is not None else ''
11403        '''
11404         Bind interface
11405        '''
11406        self.database = database if database is not None else ''
11407        self.egress_filter = egress_filter if egress_filter is not None else ''
11408        '''
11409         A filter applied to the routing logic to pin datasource to nodes.
11410        '''
11411        self.healthy = healthy if healthy is not None else False
11412        '''
11413         True if the datasource is reachable and the credentials are valid.
11414        '''
11415        self.hostname = hostname if hostname is not None else ''
11416        self.id = id if id is not None else ''
11417        '''
11418         Unique identifier of the Resource.
11419        '''
11420        self.name = name if name is not None else ''
11421        '''
11422         Unique human-readable name of the Resource.
11423        '''
11424        self.password = password if password is not None else ''
11425        self.port_override = port_override if port_override is not None else 0
11426        self.schema = schema if schema is not None else ''
11427        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11428        '''
11429         ID of the secret store containing credentials for this resource, if any.
11430        '''
11431        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11432        '''
11433         Tags is a map of key, value pairs.
11434        '''
11435        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11454    def to_dict(self):
11455        return {
11456            'bind_interface': self.bind_interface,
11457            'database': self.database,
11458            'egress_filter': self.egress_filter,
11459            'healthy': self.healthy,
11460            'hostname': self.hostname,
11461            'id': self.id,
11462            'name': self.name,
11463            'password': self.password,
11464            'port_override': self.port_override,
11465            'schema': self.schema,
11466            'secret_store_id': self.secret_store_id,
11467            'tags': self.tags,
11468            'username': self.username,
11469        }
@classmethod
def from_dict(cls, d)
11471    @classmethod
11472    def from_dict(cls, d):
11473        return cls(
11474            bind_interface=d.get('bind_interface'),
11475            database=d.get('database'),
11476            egress_filter=d.get('egress_filter'),
11477            healthy=d.get('healthy'),
11478            hostname=d.get('hostname'),
11479            id=d.get('id'),
11480            name=d.get('name'),
11481            password=d.get('password'),
11482            port_override=d.get('port_override'),
11483            schema=d.get('schema'),
11484            secret_store_id=d.get('secret_store_id'),
11485            tags=d.get('tags'),
11486            username=d.get('username'),
11487        )
class Snowsight:
11490class Snowsight:
11491    '''
11492    Snowsight is currently unstable, and its API may change, or it may be removed,
11493    without a major version bump.
11494    '''
11495    __slots__ = [
11496        'bind_interface',
11497        'egress_filter',
11498        'healthcheck_username',
11499        'healthy',
11500        'id',
11501        'name',
11502        'port_override',
11503        'samlmetadata',
11504        'secret_store_id',
11505        'subdomain',
11506        'tags',
11507    ]
11508
11509    def __init__(
11510        self,
11511        bind_interface=None,
11512        egress_filter=None,
11513        healthcheck_username=None,
11514        healthy=None,
11515        id=None,
11516        name=None,
11517        port_override=None,
11518        samlmetadata=None,
11519        secret_store_id=None,
11520        subdomain=None,
11521        tags=None,
11522    ):
11523        self.bind_interface = bind_interface if bind_interface is not None else ''
11524        '''
11525         Bind interface
11526        '''
11527        self.egress_filter = egress_filter if egress_filter is not None else ''
11528        '''
11529         A filter applied to the routing logic to pin datasource to nodes.
11530        '''
11531        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11532        self.healthy = healthy if healthy is not None else False
11533        '''
11534         True if the datasource is reachable and the credentials are valid.
11535        '''
11536        self.id = id if id is not None else ''
11537        '''
11538         Unique identifier of the Resource.
11539        '''
11540        self.name = name if name is not None else ''
11541        '''
11542         Unique human-readable name of the Resource.
11543        '''
11544        self.port_override = port_override if port_override is not None else 0
11545        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11547        '''
11548         ID of the secret store containing credentials for this resource, if any.
11549        '''
11550        self.subdomain = subdomain if subdomain is not None else ''
11551        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11552        '''
11553         Tags is a map of key, value pairs.
11554        '''
11555
11556    def __repr__(self):
11557        return '<sdm.Snowsight ' + \
11558            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11559            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11560            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11561            'healthy: ' + repr(self.healthy) + ' ' +\
11562            'id: ' + repr(self.id) + ' ' +\
11563            'name: ' + repr(self.name) + ' ' +\
11564            'port_override: ' + repr(self.port_override) + ' ' +\
11565            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11566            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11567            'subdomain: ' + repr(self.subdomain) + ' ' +\
11568            'tags: ' + repr(self.tags) + ' ' +\
11569            '>'
11570
11571    def to_dict(self):
11572        return {
11573            'bind_interface': self.bind_interface,
11574            'egress_filter': self.egress_filter,
11575            'healthcheck_username': self.healthcheck_username,
11576            'healthy': self.healthy,
11577            'id': self.id,
11578            'name': self.name,
11579            'port_override': self.port_override,
11580            'samlmetadata': self.samlmetadata,
11581            'secret_store_id': self.secret_store_id,
11582            'subdomain': self.subdomain,
11583            'tags': self.tags,
11584        }
11585
11586    @classmethod
11587    def from_dict(cls, d):
11588        return cls(
11589            bind_interface=d.get('bind_interface'),
11590            egress_filter=d.get('egress_filter'),
11591            healthcheck_username=d.get('healthcheck_username'),
11592            healthy=d.get('healthy'),
11593            id=d.get('id'),
11594            name=d.get('name'),
11595            port_override=d.get('port_override'),
11596            samlmetadata=d.get('samlmetadata'),
11597            secret_store_id=d.get('secret_store_id'),
11598            subdomain=d.get('subdomain'),
11599            tags=d.get('tags'),
11600        )

Snowsight is currently unstable, and its API may change, or it may be removed, without a major version bump.

Snowsight( bind_interface=None, egress_filter=None, healthcheck_username=None, healthy=None, id=None, name=None, port_override=None, samlmetadata=None, secret_store_id=None, subdomain=None, tags=None)
11509    def __init__(
11510        self,
11511        bind_interface=None,
11512        egress_filter=None,
11513        healthcheck_username=None,
11514        healthy=None,
11515        id=None,
11516        name=None,
11517        port_override=None,
11518        samlmetadata=None,
11519        secret_store_id=None,
11520        subdomain=None,
11521        tags=None,
11522    ):
11523        self.bind_interface = bind_interface if bind_interface is not None else ''
11524        '''
11525         Bind interface
11526        '''
11527        self.egress_filter = egress_filter if egress_filter is not None else ''
11528        '''
11529         A filter applied to the routing logic to pin datasource to nodes.
11530        '''
11531        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11532        self.healthy = healthy if healthy is not None else False
11533        '''
11534         True if the datasource is reachable and the credentials are valid.
11535        '''
11536        self.id = id if id is not None else ''
11537        '''
11538         Unique identifier of the Resource.
11539        '''
11540        self.name = name if name is not None else ''
11541        '''
11542         Unique human-readable name of the Resource.
11543        '''
11544        self.port_override = port_override if port_override is not None else 0
11545        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11546        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11547        '''
11548         ID of the secret store containing credentials for this resource, if any.
11549        '''
11550        self.subdomain = subdomain if subdomain is not None else ''
11551        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11552        '''
11553         Tags is a map of key, value pairs.
11554        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_username
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
samlmetadata
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
11571    def to_dict(self):
11572        return {
11573            'bind_interface': self.bind_interface,
11574            'egress_filter': self.egress_filter,
11575            'healthcheck_username': self.healthcheck_username,
11576            'healthy': self.healthy,
11577            'id': self.id,
11578            'name': self.name,
11579            'port_override': self.port_override,
11580            'samlmetadata': self.samlmetadata,
11581            'secret_store_id': self.secret_store_id,
11582            'subdomain': self.subdomain,
11583            'tags': self.tags,
11584        }
@classmethod
def from_dict(cls, d)
11586    @classmethod
11587    def from_dict(cls, d):
11588        return cls(
11589            bind_interface=d.get('bind_interface'),
11590            egress_filter=d.get('egress_filter'),
11591            healthcheck_username=d.get('healthcheck_username'),
11592            healthy=d.get('healthy'),
11593            id=d.get('id'),
11594            name=d.get('name'),
11595            port_override=d.get('port_override'),
11596            samlmetadata=d.get('samlmetadata'),
11597            secret_store_id=d.get('secret_store_id'),
11598            subdomain=d.get('subdomain'),
11599            tags=d.get('tags'),
11600        )
class Sybase:
11603class Sybase:
11604    __slots__ = [
11605        'bind_interface',
11606        'egress_filter',
11607        'healthy',
11608        'hostname',
11609        'id',
11610        'name',
11611        'password',
11612        'port',
11613        'port_override',
11614        'secret_store_id',
11615        'tags',
11616        'username',
11617    ]
11618
11619    def __init__(
11620        self,
11621        bind_interface=None,
11622        egress_filter=None,
11623        healthy=None,
11624        hostname=None,
11625        id=None,
11626        name=None,
11627        password=None,
11628        port=None,
11629        port_override=None,
11630        secret_store_id=None,
11631        tags=None,
11632        username=None,
11633    ):
11634        self.bind_interface = bind_interface if bind_interface is not None else ''
11635        '''
11636         Bind interface
11637        '''
11638        self.egress_filter = egress_filter if egress_filter is not None else ''
11639        '''
11640         A filter applied to the routing logic to pin datasource to nodes.
11641        '''
11642        self.healthy = healthy if healthy is not None else False
11643        '''
11644         True if the datasource is reachable and the credentials are valid.
11645        '''
11646        self.hostname = hostname if hostname is not None else ''
11647        self.id = id if id is not None else ''
11648        '''
11649         Unique identifier of the Resource.
11650        '''
11651        self.name = name if name is not None else ''
11652        '''
11653         Unique human-readable name of the Resource.
11654        '''
11655        self.password = password if password is not None else ''
11656        self.port = port if port is not None else 0
11657        self.port_override = port_override if port_override is not None else 0
11658        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11659        '''
11660         ID of the secret store containing credentials for this resource, if any.
11661        '''
11662        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11663        '''
11664         Tags is a map of key, value pairs.
11665        '''
11666        self.username = username if username is not None else ''
11667
11668    def __repr__(self):
11669        return '<sdm.Sybase ' + \
11670            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11671            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11672            'healthy: ' + repr(self.healthy) + ' ' +\
11673            'hostname: ' + repr(self.hostname) + ' ' +\
11674            'id: ' + repr(self.id) + ' ' +\
11675            'name: ' + repr(self.name) + ' ' +\
11676            'password: ' + repr(self.password) + ' ' +\
11677            'port: ' + repr(self.port) + ' ' +\
11678            'port_override: ' + repr(self.port_override) + ' ' +\
11679            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11680            'tags: ' + repr(self.tags) + ' ' +\
11681            'username: ' + repr(self.username) + ' ' +\
11682            '>'
11683
11684    def to_dict(self):
11685        return {
11686            'bind_interface': self.bind_interface,
11687            'egress_filter': self.egress_filter,
11688            'healthy': self.healthy,
11689            'hostname': self.hostname,
11690            'id': self.id,
11691            'name': self.name,
11692            'password': self.password,
11693            'port': self.port,
11694            'port_override': self.port_override,
11695            'secret_store_id': self.secret_store_id,
11696            'tags': self.tags,
11697            'username': self.username,
11698        }
11699
11700    @classmethod
11701    def from_dict(cls, d):
11702        return cls(
11703            bind_interface=d.get('bind_interface'),
11704            egress_filter=d.get('egress_filter'),
11705            healthy=d.get('healthy'),
11706            hostname=d.get('hostname'),
11707            id=d.get('id'),
11708            name=d.get('name'),
11709            password=d.get('password'),
11710            port=d.get('port'),
11711            port_override=d.get('port_override'),
11712            secret_store_id=d.get('secret_store_id'),
11713            tags=d.get('tags'),
11714            username=d.get('username'),
11715        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11619    def __init__(
11620        self,
11621        bind_interface=None,
11622        egress_filter=None,
11623        healthy=None,
11624        hostname=None,
11625        id=None,
11626        name=None,
11627        password=None,
11628        port=None,
11629        port_override=None,
11630        secret_store_id=None,
11631        tags=None,
11632        username=None,
11633    ):
11634        self.bind_interface = bind_interface if bind_interface is not None else ''
11635        '''
11636         Bind interface
11637        '''
11638        self.egress_filter = egress_filter if egress_filter is not None else ''
11639        '''
11640         A filter applied to the routing logic to pin datasource to nodes.
11641        '''
11642        self.healthy = healthy if healthy is not None else False
11643        '''
11644         True if the datasource is reachable and the credentials are valid.
11645        '''
11646        self.hostname = hostname if hostname is not None else ''
11647        self.id = id if id is not None else ''
11648        '''
11649         Unique identifier of the Resource.
11650        '''
11651        self.name = name if name is not None else ''
11652        '''
11653         Unique human-readable name of the Resource.
11654        '''
11655        self.password = password if password is not None else ''
11656        self.port = port if port is not None else 0
11657        self.port_override = port_override if port_override is not None else 0
11658        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11659        '''
11660         ID of the secret store containing credentials for this resource, if any.
11661        '''
11662        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11663        '''
11664         Tags is a map of key, value pairs.
11665        '''
11666        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11684    def to_dict(self):
11685        return {
11686            'bind_interface': self.bind_interface,
11687            'egress_filter': self.egress_filter,
11688            'healthy': self.healthy,
11689            'hostname': self.hostname,
11690            'id': self.id,
11691            'name': self.name,
11692            'password': self.password,
11693            'port': self.port,
11694            'port_override': self.port_override,
11695            'secret_store_id': self.secret_store_id,
11696            'tags': self.tags,
11697            'username': self.username,
11698        }
@classmethod
def from_dict(cls, d)
11700    @classmethod
11701    def from_dict(cls, d):
11702        return cls(
11703            bind_interface=d.get('bind_interface'),
11704            egress_filter=d.get('egress_filter'),
11705            healthy=d.get('healthy'),
11706            hostname=d.get('hostname'),
11707            id=d.get('id'),
11708            name=d.get('name'),
11709            password=d.get('password'),
11710            port=d.get('port'),
11711            port_override=d.get('port_override'),
11712            secret_store_id=d.get('secret_store_id'),
11713            tags=d.get('tags'),
11714            username=d.get('username'),
11715        )
class SybaseIQ:
11718class SybaseIQ:
11719    __slots__ = [
11720        'bind_interface',
11721        'egress_filter',
11722        'healthy',
11723        'hostname',
11724        'id',
11725        'name',
11726        'password',
11727        'port',
11728        'port_override',
11729        'secret_store_id',
11730        'tags',
11731        'username',
11732    ]
11733
11734    def __init__(
11735        self,
11736        bind_interface=None,
11737        egress_filter=None,
11738        healthy=None,
11739        hostname=None,
11740        id=None,
11741        name=None,
11742        password=None,
11743        port=None,
11744        port_override=None,
11745        secret_store_id=None,
11746        tags=None,
11747        username=None,
11748    ):
11749        self.bind_interface = bind_interface if bind_interface is not None else ''
11750        '''
11751         Bind interface
11752        '''
11753        self.egress_filter = egress_filter if egress_filter is not None else ''
11754        '''
11755         A filter applied to the routing logic to pin datasource to nodes.
11756        '''
11757        self.healthy = healthy if healthy is not None else False
11758        '''
11759         True if the datasource is reachable and the credentials are valid.
11760        '''
11761        self.hostname = hostname if hostname is not None else ''
11762        self.id = id if id is not None else ''
11763        '''
11764         Unique identifier of the Resource.
11765        '''
11766        self.name = name if name is not None else ''
11767        '''
11768         Unique human-readable name of the Resource.
11769        '''
11770        self.password = password if password is not None else ''
11771        self.port = port if port is not None else 0
11772        self.port_override = port_override if port_override is not None else 0
11773        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11774        '''
11775         ID of the secret store containing credentials for this resource, if any.
11776        '''
11777        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11778        '''
11779         Tags is a map of key, value pairs.
11780        '''
11781        self.username = username if username is not None else ''
11782
11783    def __repr__(self):
11784        return '<sdm.SybaseIQ ' + \
11785            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11786            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11787            'healthy: ' + repr(self.healthy) + ' ' +\
11788            'hostname: ' + repr(self.hostname) + ' ' +\
11789            'id: ' + repr(self.id) + ' ' +\
11790            'name: ' + repr(self.name) + ' ' +\
11791            'password: ' + repr(self.password) + ' ' +\
11792            'port: ' + repr(self.port) + ' ' +\
11793            'port_override: ' + repr(self.port_override) + ' ' +\
11794            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11795            'tags: ' + repr(self.tags) + ' ' +\
11796            'username: ' + repr(self.username) + ' ' +\
11797            '>'
11798
11799    def to_dict(self):
11800        return {
11801            'bind_interface': self.bind_interface,
11802            'egress_filter': self.egress_filter,
11803            'healthy': self.healthy,
11804            'hostname': self.hostname,
11805            'id': self.id,
11806            'name': self.name,
11807            'password': self.password,
11808            'port': self.port,
11809            'port_override': self.port_override,
11810            'secret_store_id': self.secret_store_id,
11811            'tags': self.tags,
11812            'username': self.username,
11813        }
11814
11815    @classmethod
11816    def from_dict(cls, d):
11817        return cls(
11818            bind_interface=d.get('bind_interface'),
11819            egress_filter=d.get('egress_filter'),
11820            healthy=d.get('healthy'),
11821            hostname=d.get('hostname'),
11822            id=d.get('id'),
11823            name=d.get('name'),
11824            password=d.get('password'),
11825            port=d.get('port'),
11826            port_override=d.get('port_override'),
11827            secret_store_id=d.get('secret_store_id'),
11828            tags=d.get('tags'),
11829            username=d.get('username'),
11830        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11734    def __init__(
11735        self,
11736        bind_interface=None,
11737        egress_filter=None,
11738        healthy=None,
11739        hostname=None,
11740        id=None,
11741        name=None,
11742        password=None,
11743        port=None,
11744        port_override=None,
11745        secret_store_id=None,
11746        tags=None,
11747        username=None,
11748    ):
11749        self.bind_interface = bind_interface if bind_interface is not None else ''
11750        '''
11751         Bind interface
11752        '''
11753        self.egress_filter = egress_filter if egress_filter is not None else ''
11754        '''
11755         A filter applied to the routing logic to pin datasource to nodes.
11756        '''
11757        self.healthy = healthy if healthy is not None else False
11758        '''
11759         True if the datasource is reachable and the credentials are valid.
11760        '''
11761        self.hostname = hostname if hostname is not None else ''
11762        self.id = id if id is not None else ''
11763        '''
11764         Unique identifier of the Resource.
11765        '''
11766        self.name = name if name is not None else ''
11767        '''
11768         Unique human-readable name of the Resource.
11769        '''
11770        self.password = password if password is not None else ''
11771        self.port = port if port is not None else 0
11772        self.port_override = port_override if port_override is not None else 0
11773        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11774        '''
11775         ID of the secret store containing credentials for this resource, if any.
11776        '''
11777        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11778        '''
11779         Tags is a map of key, value pairs.
11780        '''
11781        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11799    def to_dict(self):
11800        return {
11801            'bind_interface': self.bind_interface,
11802            'egress_filter': self.egress_filter,
11803            'healthy': self.healthy,
11804            'hostname': self.hostname,
11805            'id': self.id,
11806            'name': self.name,
11807            'password': self.password,
11808            'port': self.port,
11809            'port_override': self.port_override,
11810            'secret_store_id': self.secret_store_id,
11811            'tags': self.tags,
11812            'username': self.username,
11813        }
@classmethod
def from_dict(cls, d)
11815    @classmethod
11816    def from_dict(cls, d):
11817        return cls(
11818            bind_interface=d.get('bind_interface'),
11819            egress_filter=d.get('egress_filter'),
11820            healthy=d.get('healthy'),
11821            hostname=d.get('hostname'),
11822            id=d.get('id'),
11823            name=d.get('name'),
11824            password=d.get('password'),
11825            port=d.get('port'),
11826            port_override=d.get('port_override'),
11827            secret_store_id=d.get('secret_store_id'),
11828            tags=d.get('tags'),
11829            username=d.get('username'),
11830        )
class Tag:
11833class Tag:
11834    __slots__ = [
11835        'name',
11836        'value',
11837    ]
11838
11839    def __init__(
11840        self,
11841        name=None,
11842        value=None,
11843    ):
11844        self.name = name if name is not None else ''
11845        self.value = value if value is not None else ''
11846
11847    def __repr__(self):
11848        return '<sdm.Tag ' + \
11849            'name: ' + repr(self.name) + ' ' +\
11850            'value: ' + repr(self.value) + ' ' +\
11851            '>'
11852
11853    def to_dict(self):
11854        return {
11855            'name': self.name,
11856            'value': self.value,
11857        }
11858
11859    @classmethod
11860    def from_dict(cls, d):
11861        return cls(
11862            name=d.get('name'),
11863            value=d.get('value'),
11864        )
Tag(name=None, value=None)
11839    def __init__(
11840        self,
11841        name=None,
11842        value=None,
11843    ):
11844        self.name = name if name is not None else ''
11845        self.value = value if value is not None else ''
name
value
def to_dict(self)
11853    def to_dict(self):
11854        return {
11855            'name': self.name,
11856            'value': self.value,
11857        }
@classmethod
def from_dict(cls, d)
11859    @classmethod
11860    def from_dict(cls, d):
11861        return cls(
11862            name=d.get('name'),
11863            value=d.get('value'),
11864        )
class Teradata:
11867class Teradata:
11868    __slots__ = [
11869        'bind_interface',
11870        'egress_filter',
11871        'healthy',
11872        'hostname',
11873        'id',
11874        'name',
11875        'password',
11876        'port',
11877        'port_override',
11878        'secret_store_id',
11879        'tags',
11880        'username',
11881    ]
11882
11883    def __init__(
11884        self,
11885        bind_interface=None,
11886        egress_filter=None,
11887        healthy=None,
11888        hostname=None,
11889        id=None,
11890        name=None,
11891        password=None,
11892        port=None,
11893        port_override=None,
11894        secret_store_id=None,
11895        tags=None,
11896        username=None,
11897    ):
11898        self.bind_interface = bind_interface if bind_interface is not None else ''
11899        '''
11900         Bind interface
11901        '''
11902        self.egress_filter = egress_filter if egress_filter is not None else ''
11903        '''
11904         A filter applied to the routing logic to pin datasource to nodes.
11905        '''
11906        self.healthy = healthy if healthy is not None else False
11907        '''
11908         True if the datasource is reachable and the credentials are valid.
11909        '''
11910        self.hostname = hostname if hostname is not None else ''
11911        self.id = id if id is not None else ''
11912        '''
11913         Unique identifier of the Resource.
11914        '''
11915        self.name = name if name is not None else ''
11916        '''
11917         Unique human-readable name of the Resource.
11918        '''
11919        self.password = password if password is not None else ''
11920        self.port = port if port is not None else 0
11921        self.port_override = port_override if port_override is not None else 0
11922        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11923        '''
11924         ID of the secret store containing credentials for this resource, if any.
11925        '''
11926        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11927        '''
11928         Tags is a map of key, value pairs.
11929        '''
11930        self.username = username if username is not None else ''
11931
11932    def __repr__(self):
11933        return '<sdm.Teradata ' + \
11934            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11935            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11936            'healthy: ' + repr(self.healthy) + ' ' +\
11937            'hostname: ' + repr(self.hostname) + ' ' +\
11938            'id: ' + repr(self.id) + ' ' +\
11939            'name: ' + repr(self.name) + ' ' +\
11940            'password: ' + repr(self.password) + ' ' +\
11941            'port: ' + repr(self.port) + ' ' +\
11942            'port_override: ' + repr(self.port_override) + ' ' +\
11943            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11944            'tags: ' + repr(self.tags) + ' ' +\
11945            'username: ' + repr(self.username) + ' ' +\
11946            '>'
11947
11948    def to_dict(self):
11949        return {
11950            'bind_interface': self.bind_interface,
11951            'egress_filter': self.egress_filter,
11952            'healthy': self.healthy,
11953            'hostname': self.hostname,
11954            'id': self.id,
11955            'name': self.name,
11956            'password': self.password,
11957            'port': self.port,
11958            'port_override': self.port_override,
11959            'secret_store_id': self.secret_store_id,
11960            'tags': self.tags,
11961            'username': self.username,
11962        }
11963
11964    @classmethod
11965    def from_dict(cls, d):
11966        return cls(
11967            bind_interface=d.get('bind_interface'),
11968            egress_filter=d.get('egress_filter'),
11969            healthy=d.get('healthy'),
11970            hostname=d.get('hostname'),
11971            id=d.get('id'),
11972            name=d.get('name'),
11973            password=d.get('password'),
11974            port=d.get('port'),
11975            port_override=d.get('port_override'),
11976            secret_store_id=d.get('secret_store_id'),
11977            tags=d.get('tags'),
11978            username=d.get('username'),
11979        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11883    def __init__(
11884        self,
11885        bind_interface=None,
11886        egress_filter=None,
11887        healthy=None,
11888        hostname=None,
11889        id=None,
11890        name=None,
11891        password=None,
11892        port=None,
11893        port_override=None,
11894        secret_store_id=None,
11895        tags=None,
11896        username=None,
11897    ):
11898        self.bind_interface = bind_interface if bind_interface is not None else ''
11899        '''
11900         Bind interface
11901        '''
11902        self.egress_filter = egress_filter if egress_filter is not None else ''
11903        '''
11904         A filter applied to the routing logic to pin datasource to nodes.
11905        '''
11906        self.healthy = healthy if healthy is not None else False
11907        '''
11908         True if the datasource is reachable and the credentials are valid.
11909        '''
11910        self.hostname = hostname if hostname is not None else ''
11911        self.id = id if id is not None else ''
11912        '''
11913         Unique identifier of the Resource.
11914        '''
11915        self.name = name if name is not None else ''
11916        '''
11917         Unique human-readable name of the Resource.
11918        '''
11919        self.password = password if password is not None else ''
11920        self.port = port if port is not None else 0
11921        self.port_override = port_override if port_override is not None else 0
11922        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11923        '''
11924         ID of the secret store containing credentials for this resource, if any.
11925        '''
11926        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11927        '''
11928         Tags is a map of key, value pairs.
11929        '''
11930        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11948    def to_dict(self):
11949        return {
11950            'bind_interface': self.bind_interface,
11951            'egress_filter': self.egress_filter,
11952            'healthy': self.healthy,
11953            'hostname': self.hostname,
11954            'id': self.id,
11955            'name': self.name,
11956            'password': self.password,
11957            'port': self.port,
11958            'port_override': self.port_override,
11959            'secret_store_id': self.secret_store_id,
11960            'tags': self.tags,
11961            'username': self.username,
11962        }
@classmethod
def from_dict(cls, d)
11964    @classmethod
11965    def from_dict(cls, d):
11966        return cls(
11967            bind_interface=d.get('bind_interface'),
11968            egress_filter=d.get('egress_filter'),
11969            healthy=d.get('healthy'),
11970            hostname=d.get('hostname'),
11971            id=d.get('id'),
11972            name=d.get('name'),
11973            password=d.get('password'),
11974            port=d.get('port'),
11975            port_override=d.get('port_override'),
11976            secret_store_id=d.get('secret_store_id'),
11977            tags=d.get('tags'),
11978            username=d.get('username'),
11979        )
class UpdateResponseMetadata:
11982class UpdateResponseMetadata:
11983    '''
11984         UpdateResponseMetadata is reserved for future use.
11985    '''
11986    __slots__ = []
11987
11988    def __init__(self, ):
11989        pass
11990
11991    def __repr__(self):
11992        return '<sdm.UpdateResponseMetadata ' + \
11993            '>'
11994
11995    def to_dict(self):
11996        return {}
11997
11998    @classmethod
11999    def from_dict(cls, d):
12000        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
11988    def __init__(self, ):
11989        pass
def to_dict(self)
11995    def to_dict(self):
11996        return {}
@classmethod
def from_dict(cls, d)
11998    @classmethod
11999    def from_dict(cls, d):
12000        return cls()
class User:
12003class User:
12004    '''
12005         A User can connect to resources they are granted directly, or granted
12006     via roles.
12007    '''
12008    __slots__ = [
12009        'email',
12010        'first_name',
12011        'id',
12012        'last_name',
12013        'suspended',
12014        'tags',
12015    ]
12016
12017    def __init__(
12018        self,
12019        email=None,
12020        first_name=None,
12021        id=None,
12022        last_name=None,
12023        suspended=None,
12024        tags=None,
12025    ):
12026        self.email = email if email is not None else ''
12027        '''
12028         The User's email address. Must be unique.
12029        '''
12030        self.first_name = first_name if first_name is not None else ''
12031        '''
12032         The User's first name.
12033        '''
12034        self.id = id if id is not None else ''
12035        '''
12036         Unique identifier of the User.
12037        '''
12038        self.last_name = last_name if last_name is not None else ''
12039        '''
12040         The User's last name.
12041        '''
12042        self.suspended = suspended if suspended is not None else False
12043        '''
12044         The User's suspended state.
12045        '''
12046        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12047        '''
12048         Tags is a map of key, value pairs.
12049        '''
12050
12051    def __repr__(self):
12052        return '<sdm.User ' + \
12053            'email: ' + repr(self.email) + ' ' +\
12054            'first_name: ' + repr(self.first_name) + ' ' +\
12055            'id: ' + repr(self.id) + ' ' +\
12056            'last_name: ' + repr(self.last_name) + ' ' +\
12057            'suspended: ' + repr(self.suspended) + ' ' +\
12058            'tags: ' + repr(self.tags) + ' ' +\
12059            '>'
12060
12061    def to_dict(self):
12062        return {
12063            'email': self.email,
12064            'first_name': self.first_name,
12065            'id': self.id,
12066            'last_name': self.last_name,
12067            'suspended': self.suspended,
12068            'tags': self.tags,
12069        }
12070
12071    @classmethod
12072    def from_dict(cls, d):
12073        return cls(
12074            email=d.get('email'),
12075            first_name=d.get('first_name'),
12076            id=d.get('id'),
12077            last_name=d.get('last_name'),
12078            suspended=d.get('suspended'),
12079            tags=d.get('tags'),
12080        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
12017    def __init__(
12018        self,
12019        email=None,
12020        first_name=None,
12021        id=None,
12022        last_name=None,
12023        suspended=None,
12024        tags=None,
12025    ):
12026        self.email = email if email is not None else ''
12027        '''
12028         The User's email address. Must be unique.
12029        '''
12030        self.first_name = first_name if first_name is not None else ''
12031        '''
12032         The User's first name.
12033        '''
12034        self.id = id if id is not None else ''
12035        '''
12036         Unique identifier of the User.
12037        '''
12038        self.last_name = last_name if last_name is not None else ''
12039        '''
12040         The User's last name.
12041        '''
12042        self.suspended = suspended if suspended is not None else False
12043        '''
12044         The User's suspended state.
12045        '''
12046        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12047        '''
12048         Tags is a map of key, value pairs.
12049        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12061    def to_dict(self):
12062        return {
12063            'email': self.email,
12064            'first_name': self.first_name,
12065            'id': self.id,
12066            'last_name': self.last_name,
12067            'suspended': self.suspended,
12068            'tags': self.tags,
12069        }
@classmethod
def from_dict(cls, d)
12071    @classmethod
12072    def from_dict(cls, d):
12073        return cls(
12074            email=d.get('email'),
12075            first_name=d.get('first_name'),
12076            id=d.get('id'),
12077            last_name=d.get('last_name'),
12078            suspended=d.get('suspended'),
12079            tags=d.get('tags'),
12080        )
class VaultAppRoleStore:
12083class VaultAppRoleStore:
12084    __slots__ = [
12085        'id',
12086        'name',
12087        'namespace',
12088        'server_address',
12089        'tags',
12090    ]
12091
12092    def __init__(
12093        self,
12094        id=None,
12095        name=None,
12096        namespace=None,
12097        server_address=None,
12098        tags=None,
12099    ):
12100        self.id = id if id is not None else ''
12101        '''
12102         Unique identifier of the SecretStore.
12103        '''
12104        self.name = name if name is not None else ''
12105        '''
12106         Unique human-readable name of the SecretStore.
12107        '''
12108        self.namespace = namespace if namespace is not None else ''
12109        self.server_address = server_address if server_address is not None else ''
12110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12111        '''
12112         Tags is a map of key, value pairs.
12113        '''
12114
12115    def __repr__(self):
12116        return '<sdm.VaultAppRoleStore ' + \
12117            'id: ' + repr(self.id) + ' ' +\
12118            'name: ' + repr(self.name) + ' ' +\
12119            'namespace: ' + repr(self.namespace) + ' ' +\
12120            'server_address: ' + repr(self.server_address) + ' ' +\
12121            'tags: ' + repr(self.tags) + ' ' +\
12122            '>'
12123
12124    def to_dict(self):
12125        return {
12126            'id': self.id,
12127            'name': self.name,
12128            'namespace': self.namespace,
12129            'server_address': self.server_address,
12130            'tags': self.tags,
12131        }
12132
12133    @classmethod
12134    def from_dict(cls, d):
12135        return cls(
12136            id=d.get('id'),
12137            name=d.get('name'),
12138            namespace=d.get('namespace'),
12139            server_address=d.get('server_address'),
12140            tags=d.get('tags'),
12141        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12092    def __init__(
12093        self,
12094        id=None,
12095        name=None,
12096        namespace=None,
12097        server_address=None,
12098        tags=None,
12099    ):
12100        self.id = id if id is not None else ''
12101        '''
12102         Unique identifier of the SecretStore.
12103        '''
12104        self.name = name if name is not None else ''
12105        '''
12106         Unique human-readable name of the SecretStore.
12107        '''
12108        self.namespace = namespace if namespace is not None else ''
12109        self.server_address = server_address if server_address is not None else ''
12110        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12111        '''
12112         Tags is a map of key, value pairs.
12113        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12124    def to_dict(self):
12125        return {
12126            'id': self.id,
12127            'name': self.name,
12128            'namespace': self.namespace,
12129            'server_address': self.server_address,
12130            'tags': self.tags,
12131        }
@classmethod
def from_dict(cls, d)
12133    @classmethod
12134    def from_dict(cls, d):
12135        return cls(
12136            id=d.get('id'),
12137            name=d.get('name'),
12138            namespace=d.get('namespace'),
12139            server_address=d.get('server_address'),
12140            tags=d.get('tags'),
12141        )
class VaultTLSStore:
12144class VaultTLSStore:
12145    __slots__ = [
12146        'ca_cert_path',
12147        'client_cert_path',
12148        'client_key_path',
12149        'id',
12150        'name',
12151        'namespace',
12152        'server_address',
12153        'tags',
12154    ]
12155
12156    def __init__(
12157        self,
12158        ca_cert_path=None,
12159        client_cert_path=None,
12160        client_key_path=None,
12161        id=None,
12162        name=None,
12163        namespace=None,
12164        server_address=None,
12165        tags=None,
12166    ):
12167        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12168        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12169        self.client_key_path = client_key_path if client_key_path is not None else ''
12170        self.id = id if id is not None else ''
12171        '''
12172         Unique identifier of the SecretStore.
12173        '''
12174        self.name = name if name is not None else ''
12175        '''
12176         Unique human-readable name of the SecretStore.
12177        '''
12178        self.namespace = namespace if namespace is not None else ''
12179        self.server_address = server_address if server_address is not None else ''
12180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12181        '''
12182         Tags is a map of key, value pairs.
12183        '''
12184
12185    def __repr__(self):
12186        return '<sdm.VaultTLSStore ' + \
12187            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12188            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12189            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12190            'id: ' + repr(self.id) + ' ' +\
12191            'name: ' + repr(self.name) + ' ' +\
12192            'namespace: ' + repr(self.namespace) + ' ' +\
12193            'server_address: ' + repr(self.server_address) + ' ' +\
12194            'tags: ' + repr(self.tags) + ' ' +\
12195            '>'
12196
12197    def to_dict(self):
12198        return {
12199            'ca_cert_path': self.ca_cert_path,
12200            'client_cert_path': self.client_cert_path,
12201            'client_key_path': self.client_key_path,
12202            'id': self.id,
12203            'name': self.name,
12204            'namespace': self.namespace,
12205            'server_address': self.server_address,
12206            'tags': self.tags,
12207        }
12208
12209    @classmethod
12210    def from_dict(cls, d):
12211        return cls(
12212            ca_cert_path=d.get('ca_cert_path'),
12213            client_cert_path=d.get('client_cert_path'),
12214            client_key_path=d.get('client_key_path'),
12215            id=d.get('id'),
12216            name=d.get('name'),
12217            namespace=d.get('namespace'),
12218            server_address=d.get('server_address'),
12219            tags=d.get('tags'),
12220        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
12156    def __init__(
12157        self,
12158        ca_cert_path=None,
12159        client_cert_path=None,
12160        client_key_path=None,
12161        id=None,
12162        name=None,
12163        namespace=None,
12164        server_address=None,
12165        tags=None,
12166    ):
12167        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12168        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12169        self.client_key_path = client_key_path if client_key_path is not None else ''
12170        self.id = id if id is not None else ''
12171        '''
12172         Unique identifier of the SecretStore.
12173        '''
12174        self.name = name if name is not None else ''
12175        '''
12176         Unique human-readable name of the SecretStore.
12177        '''
12178        self.namespace = namespace if namespace is not None else ''
12179        self.server_address = server_address if server_address is not None else ''
12180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12181        '''
12182         Tags is a map of key, value pairs.
12183        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12197    def to_dict(self):
12198        return {
12199            'ca_cert_path': self.ca_cert_path,
12200            'client_cert_path': self.client_cert_path,
12201            'client_key_path': self.client_key_path,
12202            'id': self.id,
12203            'name': self.name,
12204            'namespace': self.namespace,
12205            'server_address': self.server_address,
12206            'tags': self.tags,
12207        }
@classmethod
def from_dict(cls, d)
12209    @classmethod
12210    def from_dict(cls, d):
12211        return cls(
12212            ca_cert_path=d.get('ca_cert_path'),
12213            client_cert_path=d.get('client_cert_path'),
12214            client_key_path=d.get('client_key_path'),
12215            id=d.get('id'),
12216            name=d.get('name'),
12217            namespace=d.get('namespace'),
12218            server_address=d.get('server_address'),
12219            tags=d.get('tags'),
12220        )
class VaultTokenStore:
12223class VaultTokenStore:
12224    __slots__ = [
12225        'id',
12226        'name',
12227        'namespace',
12228        'server_address',
12229        'tags',
12230    ]
12231
12232    def __init__(
12233        self,
12234        id=None,
12235        name=None,
12236        namespace=None,
12237        server_address=None,
12238        tags=None,
12239    ):
12240        self.id = id if id is not None else ''
12241        '''
12242         Unique identifier of the SecretStore.
12243        '''
12244        self.name = name if name is not None else ''
12245        '''
12246         Unique human-readable name of the SecretStore.
12247        '''
12248        self.namespace = namespace if namespace is not None else ''
12249        self.server_address = server_address if server_address is not None else ''
12250        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12251        '''
12252         Tags is a map of key, value pairs.
12253        '''
12254
12255    def __repr__(self):
12256        return '<sdm.VaultTokenStore ' + \
12257            'id: ' + repr(self.id) + ' ' +\
12258            'name: ' + repr(self.name) + ' ' +\
12259            'namespace: ' + repr(self.namespace) + ' ' +\
12260            'server_address: ' + repr(self.server_address) + ' ' +\
12261            'tags: ' + repr(self.tags) + ' ' +\
12262            '>'
12263
12264    def to_dict(self):
12265        return {
12266            'id': self.id,
12267            'name': self.name,
12268            'namespace': self.namespace,
12269            'server_address': self.server_address,
12270            'tags': self.tags,
12271        }
12272
12273    @classmethod
12274    def from_dict(cls, d):
12275        return cls(
12276            id=d.get('id'),
12277            name=d.get('name'),
12278            namespace=d.get('namespace'),
12279            server_address=d.get('server_address'),
12280            tags=d.get('tags'),
12281        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12232    def __init__(
12233        self,
12234        id=None,
12235        name=None,
12236        namespace=None,
12237        server_address=None,
12238        tags=None,
12239    ):
12240        self.id = id if id is not None else ''
12241        '''
12242         Unique identifier of the SecretStore.
12243        '''
12244        self.name = name if name is not None else ''
12245        '''
12246         Unique human-readable name of the SecretStore.
12247        '''
12248        self.namespace = namespace if namespace is not None else ''
12249        self.server_address = server_address if server_address is not None else ''
12250        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12251        '''
12252         Tags is a map of key, value pairs.
12253        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12264    def to_dict(self):
12265        return {
12266            'id': self.id,
12267            'name': self.name,
12268            'namespace': self.namespace,
12269            'server_address': self.server_address,
12270            'tags': self.tags,
12271        }
@classmethod
def from_dict(cls, d)
12273    @classmethod
12274    def from_dict(cls, d):
12275        return cls(
12276            id=d.get('id'),
12277            name=d.get('name'),
12278            namespace=d.get('namespace'),
12279            server_address=d.get('server_address'),
12280            tags=d.get('tags'),
12281        )